perm filename G.1[NOT,DBL] blob
sn#221895 filedate 1976-06-27 generic text, type T, neo UTF8
SYSOUT(S)
Jogging at 15026 Load av. = 2.88, used 0:03:47.1 in 0:16:54
<LENAT>S.;2
←
LOGOUT)
@
@DEL S
@DS
<LENAT>
20 FILES, 697 PAGES
1 FILES, 53 PAGES, DELETED
750 TOTAL PAGES IN USE - 500 PAGES ALLOWED
!*!*! OVER ALLOCATION BY 250 PAGES!
13963 UNUSED SYSTEM PAGES, 99437 USED
@E ?
@CON
NIL
←START)
Please type in your last name ( then carriage-return):
LENAT
Almost ready to enter AM's main loop, Doug.
More details can be obtained when you interrupt with ↑I.
Verbosity Level (1 - 10, or ?) .... 10
User-control Level ( 0 - 10, or ? ) ....3
Before deciding which new Cand to work on, I'll print my top choices.
How many Candidates would you like to see each time?
( I suggest 3): 3.
Should I tell you my reasons for each Cand I am considering selecting
each time? No
Should I tell you my reasons for the Cand I actually select each time?
Yes
Would you like to reset this waiting time? N
no
Entering AM's main loop now.
No Cand on CANDS is good enuf.
Do-thresh reduced from 500 to 333
Must find new candidates and merge them into CANDS.
(ACTIVE-EXS-E-SUGG compiling)
(ACTIVE-EXS-E-SUGG (BA1 BA2 BA3) NIL)
(ACTIVE-EXS-NOT-BDY-E-SUGG compiling)
(ACTIVE-EXS-NOT-BDY-E-SUGG (BA1 BA2 BA3) NIL)
(ANYB-D-R-E-SUGG compiling)
(ANYB-D-R-E-SUGG (BA1 BA2 BA3) NIL)
(ANYB-EXS-E-SUGG compiling)
(ANYB-EXS-E-SUGG (BA1 BA2 BA3) NIL)
(ANYB-EXS-BDY-E-SUGG compiling)
(ANYB-EXS-BDY-E-SUGG (BA1 BA2 BA3) NIL)
(CANONIZE-E-SUGG compiling)
(CANONIZE-E-SUGG (BA1 BA2 BA3) NIL)
(COALESCE-E-SUGG compiling)
(COALESCE-E-SUGG (BA1 BA2 BA3) NIL)
(INV-OP-E-SUGG compiling)
(INV-OP-E-SUGG (BA1 BA2 BA3) NIL)
(MAP-JOIN-E-SUGG compiling)
(MAP-JOIN-E-SUGG (BA1 BA2 BA3) NIL)
(MAP-REPLACE-E-SUGG compiling)
(MAP-REPLACE-E-SUGG (BA1 BA2 BA3) NIL)
(MAP-REPLACE2-E-SUGG compiling)
(MAP-REPLACE2-E-SUGG (BA1 BA2 BA3) NIL)
(RESTRICT-E-SUGG compiling)
(RESTRICT-E-SUGG (BA1 BA2 BA3) NIL)
The top 3 Cands are:
1: Fill in some examples of Set-struc
2: Fill in some examples of Bag-struc
3: Fill in some examples of Obj-equal
I choose first Cand. OK? yes.
The reason is: (We have no examples for SET-STRUC yet)
Beginning 1st cycle.
(ANYB-ANYP-E-FILLIN1 compiling)
(ANYB-ANYP-E-FILLIN1 (BA1) NIL)
(ANYB-EXS-E-FILLIN1 compiling)
(ANYB-EXS-E-FILLIN1 (BA1) NIL)
(CONSTRUCTIVE-OP-E-DEFN compiling)
(CONSTRUCTIVE-OP-E-DEFN (BA1 BA2 BA3) NIL)
(STRUCTURE-DELETE-E-INV compiling)
(STRUCTURE-DELETE-E-INV (BA1 BA2 BA3 BA4 BA5) NIL)
(STRUCTURE-MEMB-E-INV compiling)
(STRUCTURE-MEMB-E-INV (BA1 BA2 BA3 BA4 BA5) NIL)
(STRUCTURE-INSERT-E-ALGS compiling)
(STRUCTURE-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(EMPTY-STRUC-E-DEFN compiling)
(EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(SET-STRUC-E-DEFN compiling)
(SET-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(BAG-STRUC-E-DEFN compiling)
(BAG-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(OSET-STRUC-E-DEFN compiling)
(OSET-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(LIST-STRUC-E-DEFN compiling)
(LIST-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(STRUCTURE-EXS-E-FILLIN2 compiling)
(STRUCTURE-EXS-E-FILLIN2 (BA1) NIL)
(OBJECT-E-VIEW compiling)
(OBJECT-E-VIEW (BA1 BA2 BA3 BA4) NIL)
(STRUCTURE-E-VIEW compiling)
(STRUCTURE-E-VIEW (BA1 BA2 BA3 BA4) NIL)
(SET-STRUC-INSERT-E-ALGS compiling)
(SET-STRUC-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(STRUCTURE-DELETE-E-ALGS compiling)
(STRUCTURE-DELETE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(ANYB-EXS-E-FILLIN2 compiling)
(ANYB-EXS-E-FILLIN2 (BA1) (BA2))
Creating new Being, similar to SET-STRUC, named INT-SET-STRUC, but
restricted so as to make it more interesting.
An INT-SET-STRUC is any SET-STRUC for which (Each pair of
elements satisfies the same interesting predicate P (for some P)).
Filled in examples of SET-STRUC.
0 examples existed originally on SET-STRUC.
12 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(CLASS)
(CLASS ED DON)
(CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6)
(CLASS A)
(CLASS B)
(CLASS A B)
(CLASS 0 D F I M)
(CLASS A B (BAG B) (CLASS))
After eliminating duplicate and already-known entries, AM finds that.
only 8 new, distinct examples of SET-STRUC had to be added.
Do-thresh raised from 333 to 379.
This Cand used 27.515 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Int-set-struc
2: Check all examples of Set-struc
3: Fill in some examples of Obj-equal
I choose first Cand. OK? yes.
The reason is: (Any example of INT-SET-STRUC is automatically
an interesting example of SET-STRUC)
Beginning 2nd cycle.
(INT-SET-STRUC-E-DEFN compiling)
(INT-SET-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))
(OBJ-EQUAL-E-ALGS compiling)
(OBJ-EQUAL-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of INT-SET-STRUC.
Filled in examples of INT-SET-STRUC.
0 examples existed originally on INT-SET-STRUC.
13 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(CLASS)
(CLASS A)
(CLASS B)
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of INT-SET-STRUC had to be added.
Do-thresh raised from 379 to 417.
This Cand used 10.447 cpu seconds.
The top 3 Cands are:
1: Check all examples of Int-set-struc
2: Check all examples of Set-struc
3: Check all things which just barely miss being examples of
Int-set-struc
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of INT-SET-STRUC
have recently been added)
Beginning 3rd cycle.
(ANYB-EXS-E-CHECK1 compiling)
(ANYB-EXS-E-CHECK1 (BA1) NIL)
(OBJECT-EXS-E-CHECK1 compiling)
(OBJECT-EXS-E-CHECK1 (BA1) NIL)
(NONMULT-STRUC-EXS-E-CHECK1 compiling)
(NONMULT-STRUC-EXS-E-CHECK1 (BA1) NIL)
(UNORD-OBJ-EXS-E-CHECK1 compiling)
(UNORD-OBJ-EXS-E-CHECK1 (BA1) NIL)
(ANYB-EXS-E-CHECK2 compiling)
(ANYB-EXS-E-CHECK2 (BA1) NIL)
Checked examples of INT-SET-STRUC and all entries were confirmed
This Cand used 5.016 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of Int-set-struc
2: Check all examples of Set-struc
3: Check all things which just barely miss being examples of
Int-set-struc
I choose first Cand. OK? yes.
The reason is: (Examples of INT-SET-STRUC remain after checking
, to compare against other concepts)
Beginning 4th cycle.
(ANYB-TIES-E-FILLIN1 compiling)
(ANYB-TIES-E-FILLIN1 (BA1) NIL)
(NON-EMPTY-STRUC-E-DEFN compiling)
(NON-EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(ORD-PAIR-E-DEFN compiling)
(ORD-PAIR-E-DEFN (BA1 BA2 BA3) NIL)
(BAG-OF-LISTS-E-DEFN compiling)
(BAG-OF-LISTS-E-DEFN (BA1 BA2 BA3) NIL)
(SET-OF-LISTS-E-DEFN compiling)
(SET-OF-LISTS-E-DEFN (BA1 BA2 BA3) NIL)
(BAG-OF-STRUCS-E-DEFN compiling)
(BAG-OF-STRUCS-E-DEFN (BA1 BA2 BA3) NIL)
(TRUTH-VAL-E-DEFN compiling)
(TRUTH-VAL-E-DEFN (BA1 BA2 BA3) NIL)
(ATOM-OBJ-E-DEFN compiling)
(ATOM-OBJ-E-DEFN (BA1 BA2 BA3) NIL)
(SET-OF-STRUCS-E-DEFN compiling)
(SET-OF-STRUCS-E-DEFN (BA1 BA2 BA3) NIL)
(STRUCTURE-E-DEFN compiling)
(STRUCTURE-E-DEFN (BA1 BA2 BA3) NIL)
(STRUC-OF-LISTS-E-DEFN compiling)
(STRUC-OF-LISTS-E-DEFN (BA1 BA2 BA3) NIL)
(STRUC-OF-STRUCS-E-DEFN compiling)
(STRUC-OF-STRUCS-E-DEFN (BA1 BA2 BA3) NIL)
Failed. Tried to fill in new conjectures involving the concept of
INT-SET-STRUC.
This Cand used 23.826 cpu seconds.
The top 3 Cands are:
1: Check all examples of Set-struc
2: Check all things which just barely miss being examples of
Int-set-struc
3: Fill in some examples of Obj-equal
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of SET-STRUC
have recently been added)
Beginning 5th cycle.
Based on empirical experiments, AM believes that SET-STRUC may really
be no more specialized than UNORD-OBJ.
Closer inspection reveals that the evidence for this was quite flimsy.
AM will wait until some examples of any of these have been found: (
BAG-STRUC), and then see if they truly also are SET-STRUC's.
Based on empirical experiments, AM believes that SET-STRUC may really
be no more specialized than NONMULT-STRUC.
Closer inspection reveals that the evidence for this was quite flimsy.
AM will wait until some examples of any of these have been found: (
OSET-STRUC), and then see if they truly also are SET-STRUC's.
(SET-STRUC-E-INTU compiling)
(SET-STRUC-E-INTU (BA1 BA2 BA3) NIL)
Checked examples of SET-STRUC.
5 entries were there initially.
1 small modifications had to be made.
5 entries are present now.
This Cand used 8.008 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of Set-struc
2: Fill in some examples of Bag-struc
3: Fill in some examples of Oset-struc
I choose first Cand. OK? yes.
The reason is: (Examples of SET-STRUC remain after checking
, to compare against other concepts)
Beginning 6th cycle.
Failed. Tried to fill in new conjectures involving the concept of
SET-STRUC.
This Cand used 4.198 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 413 to 275
Must find new candidates and merge them into CANDS.
(INT-SET-STRUC-E-SUGG compiling)
(INT-SET-STRUC-E-SUGG (BA1 BA2 BA3) NIL)
GC: 8
29314, 29314 FREE WORDS
The top 3 Cands are:
1: Fill in some examples of Obj-equal
2: Check all things which just barely miss being examples of
Int-set-struc
3: Fill in some examples of Bag-struc
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of OBJ-EQUAL
, while trying to Fill in some Set-struc
conjectures involving the concept)
(We have no examples for OBJ-EQUAL yet)
Beginning 7th cycle.
(OBJ-EQUAL-E-DEFN compiling)
(OBJ-EQUAL-E-DEFN (BA1 BA2 BA3) NIL)
(ACTIVE-EXS-E-FILLIN1 compiling)
(ACTIVE-EXS-E-FILLIN1 (BA1) NIL)
Record of attempts to find examples:----
An ex ( sought) is: (FALSE FALSE)+-------------------------------------
--------------++------------------------------------+-------------------
-+-----------------+-------+---------+-------
Found 8 examples ( and 151 non-exs), in 5.874 secs.
A nice ratio of exs/non-exs was encountered for OBJ-EQUAL
Won't try to create a restricted interesting version of OBJ-EQUAL.
Filled in examples of OBJ-EQUAL.
0 examples existed originally on OBJ-EQUAL.
9 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((VECTOR A A B) (VECTOR A A B) T)
(FALSE FALSE T)
((VECTOR) (VECTOR) T)
((VECTOR A) (VECTOR A) T)
((VECTOR BAG) (VECTOR BAG) T)
((VECTOR A A) (VECTOR A A) T)
((CLASS) (CLASS) T)
After eliminating duplicate and already-known entries, AM finds that.
only 7 new, distinct examples of OBJ-EQUAL had to be added.
Do-thresh raised from 275 to 315.
This Cand used 12.433 cpu seconds.
AM is forgetting the entire SUGG facet of the INT-SET-STRUC concept.
Because: (No sense using this suggestion more than once).
AM is forgetting the entire SUGG facet of the INT-SET-STRUC concept.
Because: (No sense using this suggestion more than once).
The top 3 Cands are:
1: Check all examples of Obj-equal
2: Check all things which just barely miss being examples of
Int-set-struc
3: Fill in some examples of Bag-struc
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of OBJ-EQUAL
have recently been added)
Beginning 8th cycle.
Checked examples of OBJ-EQUAL and all entries were confirmed
This Cand used 2.224 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of Obj-equal
2: Check all things which just barely miss being examples of
Int-set-struc
3: Fill in some examples of Bag-struc
I choose first Cand. OK? yes.
The reason is: (Examples of OBJ-EQUAL remain after checking
, to compare against other concepts)
Beginning 9th cycle.
(ACTIVE-TIES-E-FILLIN1 compiling)
(ACTIVE-TIES-E-FILLIN1 (BA1) NIL)
Failed. Tried to fill in new conjectures involving the concept of
OBJ-EQUAL.
This Cand used 2.002 cpu seconds.
The top 3 Cands are:
1: Check all things which just barely miss being examples of
Int-set-struc
2: Fill in some examples of Bag-struc
3: Fill in some examples of Map-join
I choose first Cand. OK? yes.
The reason is: (Some things which just barely miss being examples
were recently added to INT-SET-STRUC , entries that are positive
examples of cousins of INT-SET-STRUC)
Beginning 10th cycle.
Checked things which just barely miss being examples of INT-SET-STRUC
and all entries were confirmed
This Cand used .582 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Bag-struc
2: Fill in some examples of Map-join
3: Fill in some examples of Map-replace2
I choose first Cand. OK? yes.
The 2 reasons are:
(We have no examples for BAG-STRUC yet)
(Anyb-exs specifically asked for some examples of BAG-STRUC
, while trying to Fill in some Set-struc
conjectures involving the concept)
Beginning 11st cycle.
(BAG-STRUC-INSERT-E-ALGS compiling)
(BAG-STRUC-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of BAG-STRUC.
Filled in examples of BAG-STRUC.
0 examples existed originally on BAG-STRUC.
17 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(BAG)
(BAG A)
(BAG B)
(BAG A B)
(BAG A A)
(BAG A A B)
(BAG 0 D F I M)
(BAG A B (BAG B) (CLASS))
(BAG DON ED)
(BAG R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6)
After eliminating duplicate and already-known entries, AM finds that.
only 10 new, distinct examples of BAG-STRUC had to be added.
Do-thresh raised from 312 to 330.
This Cand used 16.488 cpu seconds.
The top 3 Cands are:
1: Check all examples of Bag-struc
2: Fill in some examples of Map-join
3: Fill in some examples of Map-replace2
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of BAG-STRUC
have recently been added)
Beginning 12nd cycle.
Checked examples of BAG-STRUC.
10 entries were there initially.
9 entries are present now.
1 had to be transferred elsewhere.
Do-thresh raised from 330 to 335.
This Cand used 3.512 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of Bag-struc
2: Fill in some examples of Map-join
3: Fill in some examples of Map-replace2
I choose first Cand. OK? yes.
The reason is: (Examples of BAG-STRUC remain after checking
, to compare against other concepts)
Beginning 13rd cycle.
(INT-SET-STRUC-E-DEFN compiling)
(INT-SET-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))
GC: 1
3661, 3661 FREE WORDS
Failed. Tried to fill in new conjectures involving the concept of
BAG-STRUC.
This Cand used 11.771 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join
2: Fill in some examples of Map-replace2
3: Fill in some examples of Compose
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of MAP-JOIN ,
while trying to Fill in some Set-struc conjectures involving the concept
**)
(We have no examples for MAP-JOIN yet)
Beginning 14th cycle.
(ANY-STRUC-E-DEFN compiling)
(ANY-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(ACTIVE-E-DEFN-SUF compiling)
(ACTIVE-E-DEFN-SUF (BA1 BA2 BA3 BA4) NIL)
(ANYB-E-DEFN compiling)
(ANYB-E-DEFN (BA1 BA2 BA3) NIL)
Record of attempts to find examples:
(MAP-JOIN-E-ALGS compiling)
(MAP-JOIN-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
-------------------
An ex ( sought) is: MAP-JOIN-BAG-OF-STRUCS&IDENTITY+-------------------
-++--------+----+-------------------+----------------------+---+-------+
--------------+----------+---------------------+----
Found 12 examples ( and 151 non-exs), in 11.324 secs.
A nice ratio of exs/non-exs was encountered for MAP-JOIN
Won't try to create a restricted interesting version of MAP-JOIN.
Filled in examples of MAP-JOIN.
0 examples existed originally on MAP-JOIN.
12 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(BAG-OF-STRUCS IDENTITY MAP-JOIN-BAG-OF-STRUCS&IDENTITY)
(STRUC-OF-LISTS IDENTITY MAP-JOIN-STRUC-OF-LISTS&IDENTITY)
(BAG-OF-STRUCS REAR MAP-JOIN-BAG-OF-STRUCS&REAR)
(SET-OF-LISTS IDENTITY MAP-JOIN-SET-OF-LISTS&IDENTITY)
(SET-OF-STRUCS IDENTITY MAP-JOIN-SET-OF-STRUCS&IDENTITY)
(STRUC-OF-STRUCS IDENTITY MAP-JOIN-STRUC-OF-STRUCS&IDENTITY)
After eliminating duplicate and already-known entries, AM finds that.
only 6 new, distinct examples of MAP-JOIN had to be added.
Do-thresh raised from 334 to 337.
This Cand used 22.661 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-replace2
2: Fill in some examples of Compose
3: Fill in some examples of Coalesce
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of MAP-REPLACE2
, while trying to Fill in some Set-struc
conjectures involving the concept)
(We have no examples for MAP-REPLACE2 yet)
Beginning 15th cycle.
Record of attempts to find examples:
(MAP-REPLACE2-E-ALGS compiling)
(MAP-REPLACE2-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
-
An ex ( sought) is: MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2+--+-
-+----+--------+-----+----------+-+------+---------+-----------+-------+
+---------+------+-----+-+--+----+-------+-------------+-+--+--+---+----
--+
Found 26 examples ( and 127 non-exs), in 32.828 secs.
A nice ratio of exs/non-exs was encountered for MAP-REPLACE2
Won't try to create a restricted interesting version of MAP-REPLACE2.
Filled in examples of MAP-REPLACE2.
0 examples existed originally on MAP-REPLACE2.
26 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(BAG-OF-STRUCS INT-SET-STRUC PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2)
(NON-EMPTY-STRUC INT-SET-STRUC PROJ2
MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2)
(SET-OF-LISTS INT-SET-STRUC PROJ1
MAP-REPLACE2-SET-OF-LISTS&INT-SET-STRUC-PROJ1)
(SET-OF-STRUCS INT-SET-STRUC STRUCTURE-INSERT
MAP-REPLACE2-SET-OF-STRUCS&INT-SET-STRUC-STRUCTURE-INSERT)
(EMPTY-STRUC OSET-STRUC OSET-STRUC-DELETE
MAP-REPLACE2-EMPTY-STRUC&OSET-STRUC-OSET-STRUC-DELETE)
(SET-STRUC BAG-OF-STRUCS STRUCTURE-DELETE
MAP-REPLACE2-SET-STRUC&BAG-OF-STRUCS-STRUCTURE-DELETE)
(INT-SET-STRUC BAG-OF-STRUCS PROJ2
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2)
(SET-STRUC SET-OF-LISTS PROJ2
MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2)
(OSET-STRUC OSET-STRUC PROJ2
MAP-REPLACE2-OSET-STRUC&OSET-STRUC-PROJ2)
(BAG-OF-STRUCS BAG-OF-LISTS BAG-STRUC-INSERT
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-LISTS-BAG-STRUC-INSERT)
(NON-EMPTY-STRUC NON-EMPTY-STRUC PROJ2
MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2)
(NON-EMPTY-STRUC BAG-OF-STRUCS BAG-STRUC-INSERT
MAP-REPLACE2-NON-EMPTY-STRUC&BAG-OF-STRUCS-BAG-STRUC-INSERT)
(NON-EMPTY-STRUC LIST-STRUC PROJ2
MAP-REPLACE2-NON-EMPTY-STRUC&LIST-STRUC-PROJ2)
(BAG-OF-LISTS BAG-OF-STRUCS PROJ2
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-STRUCS-PROJ2)
(BAG-OF-STRUCS NON-EMPTY-STRUC STRUCTURE-DIFF
MAP-REPLACE2-BAG-OF-STRUCS&NON-EMPTY-STRUC-STRUCTURE-DIFF)
(SET-OF-LISTS NON-EMPTY-STRUC STRUCTURE-INSERT
MAP-REPLACE2-SET-OF-LISTS&NON-EMPTY-STRUC-STRUCTURE-INSERT)
(SET-OF-LISTS SET-OF-STRUCS PROJ2
MAP-REPLACE2-SET-OF-LISTS&SET-OF-STRUCS-PROJ2)
(OSET-STRUC SET-OF-LISTS PROJ2
MAP-REPLACE2-OSET-STRUC&SET-OF-LISTS-PROJ2)
(BAG-OF-LISTS NON-EMPTY-STRUC PROJ2
MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2)
(LIST-STRUC NON-EMPTY-STRUC PROJ2
MAP-REPLACE2-LIST-STRUC&NON-EMPTY-STRUC-PROJ2)
(BAG-OF-STRUCS EMPTY-STRUC PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2)
(STRUC-OF-LISTS BAG-OF-STRUCS STRUCTURE-INSERT
MAP-REPLACE2-STRUC-OF-LISTS&BAG-OF-STRUCS-STRUCTURE-INSERT)
(BAG-OF-STRUCS BAG-OF-STRUCS PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2)
(EMPTY-STRUC NON-EMPTY-STRUC PROJ2
MAP-REPLACE2-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2)
(INT-SET-STRUC INT-SET-STRUC STRUCTURE-INSERT
MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT)
(BAG-OF-STRUCS SET-OF-LISTS STRUCTURE-DIFF
MAP-REPLACE2-BAG-OF-STRUCS&SET-OF-LISTS-STRUCTURE-DIFF)
After eliminating duplicate and already-known entries, AM finds that.
all 26 new, distinct examples of MAP-REPLACE2 had to be added.
Do-thresh raised from 337 to 338.
This Cand used 45.262 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Compose
2: Fill in some examples of Coalesce
3: Fill in some examples of Map-replace
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of COMPOSE ,
while trying to Fill in some Set-struc conjectures involving the concept
**)
(We have no examples for COMPOSE yet)
Beginning 16th cycle.
Record of attempts to find examples:
(COMPOSE-E-ALGS compiling)
(COMPOSE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
AM can later coalesce the D-R of COMPOSE-MAP-REPLACE&RESTRICT.
An ex ( sought) is: COMPOSE-MAP-REPLACE&RESTRICT++-++
GC: 8
23490, 23490 FREE WORDS
+++
AM can later coalesce the D-R of COMPOSE-MAP-JOIN&COMPOSE.
+++
AM can later coalesce the D-R of
COMPOSE-OSET-STRUC-INSERT&OSET-STRUC-INSERT.
+
AM can later coalesce the D-R of COMPOSE-COALESCE&CANONIZE.
++
AM can later coalesce the D-R of COMPOSE-IDENTITY&MAP-REPLACE2.
+
AM can later coalesce the D-R of COMPOSE-STRUCTURE-DELETE&MAP-REPLACE2
.
++
Found 16 examples ( and 1 non-exs), in 34.564 secs.
A nice ratio of exs/non-exs was encountered for COMPOSE
Creating new Being, similar to COMPOSE, named INT-COMPOSE, but
restricted so as to make it more interesting.
An INT-COMPOSE is any COMPOSE for which (In canonical
interpretation, Range-of-op2 is a component of Domain of op1 ; And,
also: In canonical interpretation, Range-of-op1 is one component of
Domain-of-op2).
Filled in examples of COMPOSE.
0 examples existed originally on COMPOSE.
16 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(MAP-REPLACE RESTRICT COMPOSE-MAP-REPLACE&RESTRICT)
(STRUCTURE-MEMB IDENTITY COMPOSE-STRUCTURE-MEMB&IDENTITY)
(BAG-STRUC-INSERT PROJ2 COMPOSE-BAG-STRUC-INSERT&PROJ2)
(BAG-STRUC-INSERT IDENTITY COMPOSE-BAG-STRUC-INSERT&IDENTITY)
(OSET-STRUC-DELETE RESTRICT COMPOSE-OSET-STRUC-DELETE&RESTRICT)
(LIST-STRUC-INSERT OSET-STRUC-DELETE
COMPOSE-LIST-STRUC-INSERT&OSET-STRUC-DELETE)
(IDENTITY OSET-STRUC-INSERT COMPOSE-IDENTITY&OSET-STRUC-INSERT)
(MAP-JOIN COMPOSE COMPOSE-MAP-JOIN&COMPOSE)
(BAG-STRUC-INSERT OSET-STRUC-INSERT
COMPOSE-BAG-STRUC-INSERT&OSET-STRUC-INSERT)
(PROJ2 MAP-JOIN COMPOSE-PROJ2&MAP-JOIN)
(OSET-STRUC-INSERT OSET-STRUC-INSERT
COMPOSE-OSET-STRUC-INSERT&OSET-STRUC-INSERT)
(COALESCE CANONIZE COMPOSE-COALESCE&CANONIZE)
(IDENTITY LIST-STRUC-DELETE COMPOSE-IDENTITY&LIST-STRUC-DELETE)
(IDENTITY MAP-REPLACE2 COMPOSE-IDENTITY&MAP-REPLACE2)
(STRUCTURE-DELETE MAP-REPLACE2
COMPOSE-STRUCTURE-DELETE&MAP-REPLACE2)
(LIST-STRUC-DELETE MAP-JOIN COMPOSE-LIST-STRUC-DELETE&MAP-JOIN)
After eliminating duplicate and already-known entries, AM finds that.
all 16 new, distinct examples of COMPOSE had to be added.
Do-thresh raised from 338 to 338.
This Cand used 50.27 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Int-compose
2: Fill in some examples of Coalesce
3: Fill in some examples of Map-replace
I choose first Cand. OK? yes.
The reason is: (Any example of INT-COMPOSE is automatically
an interesting example of COMPOSE)
Beginning 17th cycle.
(INT-COMPOSE-E-DEFN compiling)
(INT-COMPOSE-E-DEFN (BA1 BA2 BA3) (BA4))
(COMPOSE-E-DEFN compiling)
(COMPOSE-E-DEFN (BA1 BA2 BA3) NIL)
Name of new Being is too long:
COM- MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-LISTS-BAG-STRUC-INSERT &
MAP-REPLACE2-BAG-OF-STRUCS&NON-EMPTY-STRUC-STRUCTURE-DIFF
Name of new Being is too long:
COM- MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-LISTS-BAG-STRUC-INSERT &
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2
Sorry, AM ran out of time, trying to find an example of
INT-COMPOSE, which by the way reduces to COMPOSE, plus 2
new conditions.
Record of attempts to find examples:
(INT-COMPOSE-E-ALGS compiling)
(INT-COMPOSE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
-------------------------------
An ex ( sought) is: COMPOSE-PROJ2&COMPOSE-PROJ2&MAP-JOIN+--------------
---
Name of new Being is too long:
COM- MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2 &
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2
+---------
Name of new Being is too long:
COM- MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2 &
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2
GC: 30
117, 629 FREE WORDS
AM can later coalesce the D-R of
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&BAG-OF-STRU
**-PROJ
.
+--------+-------------------------------------
AM can later coalesce the D-R of
COMPOSE-STRUCTURE-DELETE&STRUCTURE-INSERT.
+-------
AM can later coalesce the D-R of
COMPOSE-SET-STRUC-INTERSECT&SET-STRUC-DIFF.
+-+--+-------
AM can later coalesce the D-R of COMPOSE-COMPOSE&INT-COMPOSE.
+---------
AM can later coalesce the D-R of COMPOSE-PROJ2&PROJ2.
+-+
Found 11 examples ( and 129 non-exs), in 35.652 secs.
A nice ratio of exs/non-exs was encountered for INT-COMPOSE
Won't try to create a restricted interesting version of INT-COMPOSE.
Filled in examples of INT-COMPOSE.
0 examples existed originally on INT-COMPOSE.
12 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(MAP-REPLACE RESTRICT COMPOSE-MAP-REPLACE&RESTRICT)
(PROJ2 COMPOSE-PROJ2&MAP-JOIN COMPOSE-PROJ2&COMPOSE-PROJ2&MAP-JOIN
**)
(MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&INT-SET-STR
**U-PROJ)
(MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&BAG-OF-STRU
**-PROJ)
(INV-OP COALESCE COMPOSE-INV-OP&COALESCE)
(STRUCTURE-DELETE STRUCTURE-INSERT
COMPOSE-STRUCTURE-DELETE&STRUCTURE-INSERT)
(SET-STRUC-INTERSECT SET-STRUC-DIFF
COMPOSE-SET-STRUC-INTERSECT&SET-STRUC-DIFF)
(IDENTITY IDENTITY COMPOSE-IDENTITY&IDENTITY)
(COALESCE INV-OP COMPOSE-COALESCE&INV-OP)
(COMPOSE INT-COMPOSE COMPOSE-COMPOSE&INT-COMPOSE)
(PROJ2 PROJ2 COMPOSE-PROJ2&PROJ2)
(COALESCE RESTRICT COMPOSE-COALESCE&RESTRICT)
After eliminating duplicate and already-known entries, AM finds that.
all 12 new, distinct examples of INT-COMPOSE had to be added.
Do-thresh raised from 338 to 338.
This Cand used 82.258 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 338 to 225
Must find new candidates and merge them into CANDS.
(INT-COMPOSE-E-SUGG compiling)
(INT-COMPOSE-E-SUGG (BA1 BA2 BA3) NIL)
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-strucs&identity
2: Fill in some examples of Map-join-set-of-strucs&identity
3: Fill in some examples of Map-join-bag-of-strucs&rear
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 18th cycle.
(MAP-JOIN-STRUC-OF-STRUCS&IDENTITY-E-ALGS compiling)
(MAP-JOIN-STRUC-OF-STRUCS&IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
GC: 8
18242, 18242 FREE WORDS
Record of attempts to find examples:
An ex ( sought) is: (BAG)++++++++++++++++++++++++++
Found 26 examples ( and 0 non-exs), in 1.511 secs.
A nice ratio of exs/non-exs was encountered for
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY
Won't try to create a restricted interesting version of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY.
Filled in examples of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY.
0 examples existed originally on
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY.
27 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((BAG) (BAG))
After eliminating duplicate and already-known entries, AM finds that.
only 1 new, distinct examples of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY had
to be added.
Do-thresh raised from 225 to 294.
This Cand used 17.901 cpu seconds.
AM is forgetting the entire SUGG facet of the INT-COMPOSE concept.
Because: (No sense using this suggestion more than once).
AM is forgetting the entire SUGG facet of the INT-COMPOSE concept.
Because: (No sense using this suggestion more than once).
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-bag-of-strucs&rear
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 19th cycle.
(MAP-JOIN-SET-OF-STRUCS&IDENTITY-E-ALGS compiling)
(MAP-JOIN-SET-OF-STRUCS&IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of
MAP-JOIN-SET-OF-STRUCS&IDENTITY.
Filled in examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
0 examples existed originally on MAP-JOIN-SET-OF-STRUCS&IDENTITY
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY had to
be added.
Do-thresh raised from 294 to 349.
This Cand used 15.237 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-bag-of-strucs&rear
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Check all examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-BAG-OF-STRUCS&REAR might
turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 20th cycle.
(MAP-JOIN-BAG-OF-STRUCS&REAR-E-ALGS compiling)
(MAP-JOIN-BAG-OF-STRUCS&REAR-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Record of attempts to find examples:
An ex ( sought) is: (BAG)++++++++++++++++++++++++++
Found 26 examples ( and 0 non-exs), in 1.171 secs.
A nice ratio of exs/non-exs was encountered for
MAP-JOIN-BAG-OF-STRUCS&REAR
Won't try to create a restricted interesting version of
MAP-JOIN-BAG-OF-STRUCS&REAR.
Filled in examples of MAP-JOIN-BAG-OF-STRUCS&REAR.
0 examples existed originally on MAP-JOIN-BAG-OF-STRUCS&REAR.
27 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((BAG) (BAG))
After eliminating duplicate and already-known entries, AM finds that.
only 1 new, distinct examples of MAP-JOIN-BAG-OF-STRUCS&REAR had to be
added.
Do-thresh raised from 349 to 393.
This Cand used 14.793 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Check all examples of Map-join-bag-of-strucs&rear
3: Check all examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 21st cycle.
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY-E-ALGS compiling)
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Filled in examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
0 examples existed originally on MAP-JOIN-STRUC-OF-LISTS&IDENTITY
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY had
to be added.
Do-thresh raised from 393 to 428.
This Cand used 15.008 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-struc-of-lists&identity
2: Check all examples of Map-join-bag-of-strucs&rear
3: Check all examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY have recently been added)
Beginning 22nd cycle.
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY-E-DEFN compiling)
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
Won't bother looking for ties to MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Checked examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 3.493 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-bag-of-strucs&rear
2: Check all examples of Map-join-set-of-strucs&identity
3: Check all examples of Map-join-struc-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-BAG-OF-STRUCS&REAR have recently been added)
Beginning 23rd cycle.
(MAP-JOIN-BAG-OF-STRUCS&REAR-E-DEFN compiling)
(MAP-JOIN-BAG-OF-STRUCS&REAR-E-DEFN (BA1 BA2 BA3) NIL)
Checked examples of MAP-JOIN-BAG-OF-STRUCS&REAR and all entries were
confirmed
This Cand used 2.626 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-set-of-strucs&identity
2: Check all examples of Map-join-struc-of-strucs&identity
3: Coalesce Map-replace2
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-SET-OF-STRUCS&IDENTITY have recently been added)
Beginning 24th cycle.
(MAP-JOIN-SET-OF-STRUCS&IDENTITY-E-DEFN compiling)
(MAP-JOIN-SET-OF-STRUCS&IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
GC: 8
18785, 18785 FREE WORDS
Won't bother looking for ties to MAP-JOIN-SET-OF-STRUCS&IDENTITY.
Checked examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 3.469 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-struc-of-strucs&identity
2: Coalesce Map-replace2
3: Coalesce Int-compose
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY have recently been added)
Beginning 25th cycle.
(MAP-JOIN-STRUC-OF-STRUCS&IDENTITY-E-DEFN compiling)
(MAP-JOIN-STRUC-OF-STRUCS&IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
Checked examples of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY and all entries
were confirmed
This Cand used 2.676 cpu seconds.
The top 3 Cands are:
1: Coalesce Map-replace2
2: Coalesce Int-compose
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2 is interesting , an Operation
with at least two arguments , 26 known examples , and either I have
never tried to coalesce it or else I am desparate)
Beginning 26th cycle.
(COALESCE-E-ALGS compiling)
(COALESCE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
AM will merge the 2 nd and the 1 st arguments of MAP-REPLACE2; that is
, ANY-STRUC and ANY-STRUC.
Do-thresh raised from 424 to 434.
This Cand used 3.938 cpu seconds.
The top 3 Cands are:
1: Coalesce Int-compose
2: Coalesce Map-join
3: Coalesce Compose
I choose first Cand. OK? yes.
The reason is: (INT-COMPOSE is interesting , an Operation
with at least two arguments , 12 known examples , and either I have
never tried to coalesce it or else I am desparate)
Beginning 27th cycle.
AM will merge the 2 nd and the 1 st arguments of INT-COMPOSE; that is,
OPERATION and OPERATION.
Do-thresh raised from 434 to 442.
This Cand used .83 cpu seconds.
The top 3 Cands are:
1: Coalesce Map-join
2: Coalesce Compose
3: Construct an operation which is the inverse of: Map-join
I choose first Cand. OK? yes.
The reason is: (MAP-JOIN is interesting , an Operation with
at least two arguments , 6 known examples , and either I have never
tried to coalesce it or else I am desparate)
Beginning 28th cycle.
This Cand used .491 cpu seconds.
The top 3 Cands are:
1: Coalesce Compose
2: Construct an operation which is the inverse of: Map-join
3: Construct an operation which is the inverse of: Int-compose
I choose first Cand. OK? yes.
The reason is: (COMPOSE is interesting , an Operation with
at least two arguments , 16 known examples , and either I have never
tried to coalesce it or else I am desparate)
Beginning 29th cycle.
AM will merge the 1 st and the 2 nd arguments of COMPOSE; that is,
OPERATION and OPERATION.
Do-thresh raised from 441 to 443.
This Cand used .66 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 443 to 295
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Check all domain/range specifications of
Map-join-struc-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 30th cycle.
(MAP-JOIN-SET-OF-LISTS&IDENTITY-E-ALGS compiling)
(MAP-JOIN-SET-OF-LISTS&IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of
MAP-JOIN-SET-OF-LISTS&IDENTITY.
Filled in examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
0 examples existed originally on MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-SET-OF-LISTS&IDENTITY had to
be added.
Do-thresh raised from 294 to 417.
This Cand used 11.817 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Check all domain/range specifications of
Map-join-struc-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-SET-OF-LISTS&IDENTITY have recently been added)
Beginning 31st cycle.
(MAP-JOIN-SET-OF-LISTS&IDENTITY-E-DEFN compiling)
(MAP-JOIN-SET-OF-LISTS&IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
Won't bother looking for ties to MAP-JOIN-SET-OF-LISTS&IDENTITY.
Checked examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 2.935 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Check all boundary examples of Map-join-set-of-lists&identity
3: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Check all boundary examples of Map-join-set-of-lists&identity
2: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
3: Check all domain/range specifications of
Map-join-struc-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Some boundary examples were recently added
to MAP-JOIN-SET-OF-LISTS&IDENTITY , entries that AM previously thought
were examples)
Beginning 32nd cycle.
(ANYB-EXS-BDY-E-CHECK1 compiling)
(ANYB-EXS-BDY-E-CHECK1 (BA1) NIL)
(ANYB-EXS-BDY-E-CHECK2 compiling)
(ANYB-EXS-BDY-E-CHECK2 (BA1) NIL)
(SET-STRUC-INTERSECT-E-ALGS compiling)
(SET-STRUC-INTERSECT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Checked boundary examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 entries were there initially.
1 had to be completely discarded.
1 entries are present now.
Do-thresh raised from 415 to 430.
This Cand used 4.59 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 430 to 286
Must find new candidates and merge them into CANDS.
GC: 8
18239, 18239 FREE WORDS
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
3: Check all domain/range specifications of
Map-join-struc-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
2: Check all domain/range specifications of
Map-join-struc-of-strucs&identity
3: Check all domain/range specifications of
Map-join-bag-of-strucs&rear
I choose first Cand. OK? yes.
The reason is: (Examples of MAP-JOIN-SET-OF-LISTS&IDENTITY
remain after checking , to compare against other concepts)
Beginning 33rd cycle.
(ANYTHING-E-DEFN compiling)
(ANYTHING-E-DEFN (BA1 BA2 BA3) NIL)
(IDENTITY-E-DEFN compiling)
(IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
(COMPOSE-IDENTITY&IDENTITY-E-DEFN compiling)
(COMPOSE-IDENTITY&IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
(COMPOSE-IDENTITY&IDENTITY-E-ALGS compiling)
(COMPOSE-IDENTITY&IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(IDENTITY-E-ALGS compiling)
(IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Failed. Tried to fill in new conjectures involving the concept of
MAP-JOIN-SET-OF-LISTS&IDENTITY.
This Cand used 21.569 cpu seconds.
The top 3 Cands are:
1: Check all domain/range specifications of
Map-join-struc-of-strucs&identity
2: Check all domain/range specifications of
Map-join-bag-of-strucs&rear
3: Construct an operation which is the inverse of: Map-join
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY
might be STRUC-OF-STRUCS i.e. , the range the same as its domain
, which would be more symmetric ; and also there are some examples
of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY known to test this on)
Beginning 34th cycle.
(ANYB-D-R-E-CHECK2 compiling)
(ANYB-D-R-E-CHECK2 (BA1) NIL)
Seeing if range of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY is really
STRUC-OF-STRUCS.
All examples confirm this guess.
Seeing if range of MAP-JOIN-STRUC-OF-STRUCS&IDENTITY is really
STRUC-OF-STRUCS.
All examples confirm this guess.
Checked domain/range specifications of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY and all entries were confirmed
This Cand used 1.846 cpu seconds.
The top 3 Cands are:
1: Check all domain/range specifications of
Map-join-bag-of-strucs&rear
2: Construct an operation which is the inverse of: Map-join
3: Construct an operation which is the inverse of: Int-compose
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-BAG-OF-STRUCS&REAR might
be BAG-OF-STRUCS i.e. , the range the same as its domain , which
would be more symmetric ; and also there are some examples of
MAP-JOIN-BAG-OF-STRUCS&REAR known to test this on)
Beginning 35th cycle.
Seeing if range of MAP-JOIN-BAG-OF-STRUCS&REAR is really BAG-OF-STRUCS
.
All examples confirm this guess.
Seeing if range of MAP-JOIN-BAG-OF-STRUCS&REAR is really BAG-OF-STRUCS
.
All examples confirm this guess.
Checked domain/range specifications of MAP-JOIN-BAG-OF-STRUCS&REAR and
all entries were confirmed
This Cand used .822 cpu seconds.
The top 3 Cands are:
1: Construct an operation which is the inverse of: Map-join
2: Construct an operation which is the inverse of: Int-compose
3: Construct an operation which is the inverse of: Map-replace2
I choose first Cand. OK? yes.
The reason is: (MAP-JOIN is interesting , an Operation ,
6 known examples , and I have never tried to invert it)
Beginning 36th cycle.
(INV-OP-E-ALGS compiling)
(INV-OP-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Do-thresh raised from 280 to 297.
This Cand used 1.921 cpu seconds.
The top 3 Cands are:
1: Construct an operation which is the inverse of: Int-compose
2: Construct an operation which is the inverse of: Map-replace2
3: Fill in some examples of
Map-replace2-set-struc&set-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (INT-COMPOSE is interesting , an Operation
, 12 known examples , and I have never tried to invert it)
Beginning 37th cycle.
GC: 8
18022, 18022 FREE WORDS
Do-thresh raised from 297 to 310.
This Cand used .992 cpu seconds.
The top 3 Cands are:
1: Construct an operation which is the inverse of: Map-replace2
2: Fill in some examples of
Map-replace2-set-struc&set-of-lists-proj2
3: Check all boundary examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2 is interesting , an Operation
, 26 known examples , and I have never tried to invert it)
Beginning 38th cycle.
Do-thresh raised from 310 to 319.
This Cand used .819 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Map-replace2-set-struc&set-of-lists-proj2
2: Check all boundary examples of Map-join-set-of-strucs&identity
3: Check all boundary examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (We have no examples for
MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 yet)
Beginning 39th cycle.
(MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2-E-ALGS compiling)
(MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2-E-ALGS (BA1 BA2 BA3 BA4
BA5) NIL)
(PROJ2-E-ALGS compiling)
(PROJ2-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of
MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2.
Filled in examples of MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2.
0 examples existed originally on
MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((CLASS DON ED) NIL (CLASS NIL NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of
MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 had to be added.
Do-thresh raised from 319 to 325.
This Cand used 14.743 cpu seconds.
The top 3 Cands are:
1: Check all boundary examples of Map-join-set-of-strucs&identity
2: Check all boundary examples of Map-join-struc-of-lists&identity
3: Construct an operation which is the inverse of: Compose
I choose first Cand. OK? yes.
The reason is: (Some boundary examples were recently added
to MAP-JOIN-SET-OF-STRUCS&IDENTITY , entries that AM previously thought
were examples)
Beginning 40th cycle.
Checked boundary examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
1 entries were there initially.
1 had to be completely discarded.
1 entries are present now.
Do-thresh raised from 325 to 330.
This Cand used .948 cpu seconds.
The top 3 Cands are:
1: Check all boundary examples of Map-join-struc-of-lists&identity
2: Construct an operation which is the inverse of: Compose
3: Fill in some examples of Non-empty-struc
I choose first Cand. OK? yes.
The reason is: (Some boundary examples were recently added
to MAP-JOIN-STRUC-OF-LISTS&IDENTITY , entries that AM previously
thought were examples)
Beginning 41st cycle.
Checked boundary examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
1 entries were there initially.
1 had to be completely discarded.
1 entries are present now.
Do-thresh raised from 330 to 334.
This Cand used .949 cpu seconds.
The top 3 Cands are:
1: Construct an operation which is the inverse of: Compose
2: Fill in some examples of Non-empty-struc
3: Fill in some examples of Empty-struc
I choose first Cand. OK? yes.
The reason is: (COMPOSE is interesting , an Operation , 16
known examples , and I have never tried to invert it)
Beginning 42nd cycle.
Do-thresh raised from 334 to 337.
This Cand used .638 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 337 to 224
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 43rd cycle.
GC: 8
16903, 16903 FREE WORDS
Won't try to create a restricted interesting version of
MAP-JOIN-SET-OF-STRUCS&IDENTITY.
Filled in examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
0 examples existed originally on MAP-JOIN-SET-OF-STRUCS&IDENTITY
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY had to
be added.
Do-thresh raised from 224 to 354.
This Cand used 11.528 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Check all examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Check all examples of Map-join-set-of-strucs&identity
3: Coalesce Map-replace2-set-struc&set-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 44th cycle.
Won't try to create a restricted interesting version of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Filled in examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
0 examples existed originally on MAP-JOIN-STRUC-OF-LISTS&IDENTITY
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY had
to be added.
Do-thresh raised from 353 to 457.
This Cand used 11.383 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-struc-of-lists&identity
2: Check all examples of Map-join-set-of-strucs&identity
3: Coalesce Map-replace2-set-struc&set-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY have recently been added)
Beginning 45th cycle.
Won't bother looking for ties to MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Checked examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 1.198 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-set-of-strucs&identity
2: Coalesce Map-replace2-set-struc&set-of-lists-proj2
3: Check all boundary examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-SET-OF-STRUCS&IDENTITY have recently been added)
Beginning 46th cycle.
Won't bother looking for ties to MAP-JOIN-SET-OF-STRUCS&IDENTITY.
Checked examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 1.481 cpu seconds.
The top 3 Cands are:
1: Coalesce Map-replace2-set-struc&set-of-lists-proj2
2: Check all boundary examples of Map-join-struc-of-lists&identity
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 is
interesting , an Operation with at least two arguments , 1 known
examples , and either I have never tried to coalesce it or else I
am desparate)
Beginning 47th cycle.
AM will merge the 2 nd and the 1 st arguments of
MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2; that is, SET-OF-LISTS and
SET-STRUC.
Do-thresh raised from 455 to 473.
This Cand used .977 cpu seconds.
The top 3 Cands are:
1: Check all boundary examples of Map-join-struc-of-lists&identity
2: Coalesce Map-join
3: Check all boundary examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? πinterrupted before READP
(READP broken)
:GETP(OBJ-EQUAL SPEC)
(STRUCTURE-EQUAL)
:
GETP(OBJ-EQUAL GENL)
NIL
:
GETP(OBJ-EQUAL EXS)
(((VECTOR A A B) (VECTOR A A B) T) (FALSE FALSE T) ((VECTOR) (VECTOR)
T) ((VECTOR A) (VECTOR A) T) ((VECTOR BAG) (VECTOR BAG) T) ((VECTOR
A A) (VECTOR A A) T) ((CLASS) (CLASS) T))
:
PUT(OBJ-EQUAL EXS)
NIL
:
OK
READP
yes.
The reason is: (Some boundary examples were recently added
to MAP-JOIN-STRUC-OF-LISTS&IDENTITY , entries that AM previously
thought were examples)
AM recently tried this same Cand, so let's skip it now.
No Cand on CANDS is good enuf.
Do-thresh reduced from 472 to 314
Must find new candidates and merge them into CANDS.
π
?: (W, I, E, M, N, ?, Q) I
Interestingness of...? (FILLIN OBJ-EQUAL EXS)
R/L?
R
How much? 10
If you know why, tell me: (Direct suggestion by Doug)
Running at 420346 Load av. = 1.93, used 0:19:46.1 in 0:55:41
GC: 8
14117, 14117 FREE WORDS
Running at 6620 Load av. = 1.91, used 0:20:31.9 in 0:56:36
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The 2 reasons are:
(The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY might turn out
to be the same as its domain , but there are no examples around to
test this hypothesis on)
(Anyb-exs specifically asked for some examples of
MAP-JOIN-SET-OF-STRUCS&IDENTITY , while trying to Execute Coalesce
algorithms to compute Map-replace2-set-struc&set-of-lists-proj2)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Fill in some examples of Obj-equal
I choose first Cand. OK? yes.
The 2 reasons are:
(The range of MAP-JOIN-SET-OF-LISTS&IDENTITY might turn out
to be the same as its domain , but there are no examples around to
test this hypothesis on)
(Anyb-exs specifically asked for some examples of
MAP-JOIN-SET-OF-LISTS&IDENTITY , while trying to Execute Coalesce
algorithms to compute Map-replace2-set-struc&set-of-lists-proj2)
Beginning 48th cycle.
Won't try to create a restricted interesting version of
MAP-JOIN-SET-OF-LISTS&IDENTITY.
Filled in examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
0 examples existed originally on MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-SET-OF-LISTS&IDENTITY had to
be added.
Do-thresh raised from 313 to 450.
This Cand used 11.321 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Fill in some examples of Obj-equal
3: Check all examples of Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The 2 reasons are:
(The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY might turn out
to be the same as its domain , but there are no examples around to
test this hypothesis on)
(Anyb-exs specifically asked for some examples of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY , while trying to Execute Coalesce
algorithms to compute Map-replace2-set-struc&set-of-lists-proj2)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Obj-equal
2: Check all examples of Map-join-set-of-lists&identity
3: Coalesce Map-join
I choose first Cand. OK? yes.
The 3 reasons are:
(We have no examples for OBJ-EQUAL yet)
(Anyb-exs specifically asked for some examples of OBJ-EQUAL
, while trying to Execute Coalesce algorithms to compute
Map-replace2-set-struc&set-of-lists-proj2)
(Direct suggestion by Doug)
Beginning 49th cycle.
Record of attempts to find examples:-----------------------------------
----------
An ex ( sought) is: ((VECTOR BAG) (VECTOR BAG))+-----------------------
--+--------------------+----------------------------------------------+-
-+---
GC: 8
Running at 22467 Load av. = 1.75, used 0:21:16.9 in 0:57:50
16858, 16858 FREE WORDS
----------
Found 5 examples ( and 151 non-exs), in 6.388 secs.
Ratio of exs to non-exs is too low ( 5 / 151); Exs are too sparse.
AM will sometime try to generalize OBJ-EQUAL.
Won't try to create a restricted interesting version of OBJ-EQUAL.
Filled in examples of OBJ-EQUAL.
0 examples existed originally on OBJ-EQUAL.
6 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((VECTOR B A) (VECTOR B A) T)
((VECTOR BAG) (VECTOR BAG) T)
(T T T)
((VECTOR A B) (VECTOR A B) T)
((BAG) (BAG) T)
After eliminating duplicate and already-known entries, AM finds that.
only 5 new, distinct examples of OBJ-EQUAL had to be added.
Do-thresh raised from 449 to 548.
This Cand used 13.623 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-set-of-lists&identity
2: Check all examples of Obj-equal
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-SET-OF-LISTS&IDENTITY have recently been added)
Beginning 50th cycle.
Won't bother looking for ties to MAP-JOIN-SET-OF-LISTS&IDENTITY.
Checked examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 1.329 cpu seconds.
The top 3 Cands are:
1: Check all examples of Obj-equal
2: Check all boundary examples of Map-join-set-of-lists&identity
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of OBJ-EQUAL
have recently been added)
Beginning 51st cycle.
Checked examples of OBJ-EQUAL and all entries were confirmed
This Cand used 1.689 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of Obj-equal
2: Check all boundary examples of Map-join-set-of-lists&identity
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (Examples of OBJ-EQUAL remain after checking
, to compare against other concepts)
Beginning 52nd cycle.
Failed. Tried to fill in new conjectures involving the concept of
OBJ-EQUAL.
This Cand used .905 cpu seconds.
The top 3 Cands are:
1: Check all boundary examples of Map-join-set-of-lists&identity
2: Coalesce Map-join
3: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (Some boundary examples were recently added
to MAP-JOIN-SET-OF-LISTS&IDENTITY , entries that AM previously thought
were examples)
Beginning 53rd cycle.
Checked boundary examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
2 entries were there initially.
2 had to be completely discarded.
1 entries are present now.
Do-thresh raised from 545 to 548.
This Cand used .928 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 548 to 365
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Fill in some examples of Map-join-bag-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Fill in some examples of Map-join-bag-of-strucs&identity
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-bag-of-strucs&identity
2: Coalesce Map-join
3: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-BAG-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 54th cycle.
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY-E-ALGS compiling)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
GC: 8
17520, 17520 FREE WORDS
Record of attempts to find examples:
An ex ( sought) is: (BAG)++++++++++++++++++++++++++
Found 26 examples ( and 0 non-exs), in .997 secs.
A nice ratio of exs/non-exs was encountered for
MAP-JOIN-BAG-OF-STRUCS&IDENTITY
Won't try to create a restricted interesting version of
MAP-JOIN-BAG-OF-STRUCS&IDENTITY.
Filled in examples of MAP-JOIN-BAG-OF-STRUCS&IDENTITY.
0 examples existed originally on MAP-JOIN-BAG-OF-STRUCS&IDENTITY
.
27 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((BAG) (BAG))
After eliminating duplicate and already-known entries, AM finds that.
only 1 new, distinct examples of MAP-JOIN-BAG-OF-STRUCS&IDENTITY had
to be added.
Do-thresh raised from 362 to 489.
This Cand used 14.27 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-bag-of-strucs&identity
2: Coalesce Map-join
3: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-BAG-OF-STRUCS&IDENTITY have recently been added)
Beginning 55th cycle.
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY-E-DEFN compiling)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY-E-DEFN (BA1 BA2 BA3) NIL)
Checked examples of MAP-JOIN-BAG-OF-STRUCS&IDENTITY and all entries
were confirmed
This Cand used 2.488 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 488 to 325
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of
Coa-map-replace2-set-struc&set-of-lists-proj2
2: Fill in some examples of Map-join-set-of-strucs&identity
3: Fill in some examples of Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The 3 reasons are:
(Anyb-exs specifically asked for some examples of
COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 , while trying to
Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for
COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 yet)
(The range of COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 56th cycle.
GC: 8
14054, 14054 FREE WORDS
Won't try to create a restricted interesting version of
COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2.
Failed. Tried to fill in new examples of
COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2.
This Cand used 15.495 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? ?
There are 173 total Candidates on CANDS.
In more detail, the top Cands are:
1: value = 1000; Fill in some examples of
Map-join-set-of-strucs&identity
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
2: value = 1000; Fill in some examples of
Map-join-set-of-lists&identity
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
3: value = 1000; Fill in some examples of
Map-join-struc-of-lists&identity
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
4: value = 859; Check all examples of
Coa-map-replace2-set-struc&set-of-lists-proj2
The reason is: (Some new , unchecked examples of
COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 have recently been added)
5: value = 591; Check all domain/range specifications of
Map-join-bag-of-strucs&identity
The reason is: (The range of MAP-JOIN-BAG-OF-STRUCS&IDENTITY
might be BAG-OF-STRUCS i.e. , the range the same as its domain ,
which would be more symmetric ; and also there are some examples of
MAP-JOIN-BAG-OF-STRUCS&IDENTITY known to test this on)
6: value = 466; Coalesce Map-join
The reason is: (MAP-JOIN is interesting , an Operation with
at least two arguments , 6 known examples , and either I have never
tried to coalesce it or else I am desparate)
Please type y, n, a number, or just wait 4 seconds.
yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Check all examples of
Coa-map-replace2-set-struc&set-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Check all examples of
Coa-map-replace2-set-struc&set-of-lists-proj2
3: Check all domain/range specifications of
Map-join-bag-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Check all examples of
Coa-map-replace2-set-struc&set-of-lists-proj2
2: Check all domain/range specifications of
Map-join-bag-of-strucs&identity
3: Coalesce Map-join
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 have recently been added)
Beginning 57th cycle.
This Cand used .481 cpu seconds.
The top 3 Cands are:
1: Check all domain/range specifications of
Map-join-bag-of-strucs&identity
2: Coalesce Map-join
3: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-BAG-OF-STRUCS&IDENTITY
might be BAG-OF-STRUCS i.e. , the range the same as its domain ,
which would be more symmetric ; and also there are some examples of
MAP-JOIN-BAG-OF-STRUCS&IDENTITY known to test this on)
Beginning 58th cycle.
Seeing if range of MAP-JOIN-BAG-OF-STRUCS&IDENTITY is really
BAG-OF-STRUCS.
All examples confirm this guess.
Seeing if range of MAP-JOIN-BAG-OF-STRUCS&IDENTITY is really
BAG-OF-STRUCS.
All examples confirm this guess.
Checked domain/range specifications of MAP-JOIN-BAG-OF-STRUCS&IDENTITY
and all entries were confirmed
This Cand used 1.336 cpu seconds.
The top 3 Cands are:
1: Coalesce Map-join
2: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
3: Fill in some conjectures involving the concept of
Map-join-bag-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (MAP-JOIN is interesting , an Operation with
at least two arguments , 6 known examples , and either I have never
tried to coalesce it or else I am desparate)
Beginning 59th cycle.
This Cand used .538 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of
Map-join-set-of-lists&identity
2: Fill in some conjectures involving the concept of
Map-join-bag-of-strucs&identity
3: Check all boundary examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Examples of MAP-JOIN-SET-OF-LISTS&IDENTITY
remain after checking , to compare against other concepts)
Beginning 60th cycle.
Failed. Tried to fill in new conjectures involving the concept of
MAP-JOIN-SET-OF-LISTS&IDENTITY.
This Cand used 19.989 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of
Map-join-bag-of-strucs&identity
2: Check all boundary examples of Map-join-set-of-strucs&identity
3: Construct an operation which is the inverse of:
Map-replace2-set-struc&set-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (Examples of MAP-JOIN-BAG-OF-STRUCS&IDENTITY
remain after checking , to compare against other concepts)
Beginning 61st cycle.
πinterrupted before FRIPPLE-S
(FRIPPLE-S broken)
:do-thresh
u.b.a.
do-thresh
(FRIPPLE-S broken)
:DO-THRESH
317
:SET(DO-THRESH 10)
(DO-THRESH reset)
10
:
SET(INTHRESH 10)
(INTHRESH reset)
10
:
OK
FRIPPLE-S
MAP-JOIN-BAG-OF-STRUCS&IDENTITY apparently is a specialization of
IDENTITY.
MAP-JOIN-BAG-OF-STRUCS&IDENTITY apparently is a specialization of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY.
MAP-JOIN-BAG-OF-STRUCS&IDENTITY appears to be the same as
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY.
Should I merge those two concepts together (destructively)?No
MAP-JOIN-BAG-OF-STRUCS&IDENTITY apparently is a specialization of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
MAP-JOIN-BAG-OF-STRUCS&IDENTITY apparently is a specialization of
MAP-JOIN-BAG-OF-STRUCS&REAR.
MAP-JOIN-BAG-OF-STRUCS&IDENTITY appears to be the same as
MAP-JOIN-BAG-OF-STRUCS&REAR.
πππShould I merge those two concepts together (destructively)?No
πππ MAP-JOIN-BAG-OF-STRUCS&IDENTITY apparently is a specialization of
COMPOSE-IDENTITY&IDENTITY.
(FIRST-E-DEFN compiling)
(FIRST-E-DEFN (BA1 BA2 BA3) NIL)
(FIRST-E-ALGS compiling)
(FIRST-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(FINAL-E-DEFN compiling)
(FINAL-E-DEFN (BA1 BA2 BA3) NIL)
GC: 8
Running at 22302 Load av. = 1.65, used 0:25:11.8 in 1:05:50
13666, 13666 FREE WORDS
(FINAL-E-ALGS compiling)
(FINAL-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(REAR-E-DEFN compiling)
(REAR-E-DEFN (BA1 BA2 BA3) NIL)
(REAR-E-ALGS compiling)
(REAR-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
MAP-JOIN-BAG-OF-STRUCS&IDENTITY apparently is a specialization of REAR
.
Based on the example ((BAG) (BAG)) of MAP-JOIN-BAG-OF-STRUCS&IDENTITY,
AM will consider the following hypotheses: For each argument x,
MAP-JOIN-BAG-OF-STRUCS&IDENTITY returns a group of structures as its
value, and at least one of these structures is of type Y, where Y is
potentially one of these: NIL.
Of these, the following were confirmed for all examples: NIL.
After eliminating Generalizations of these concepts, the following
remain: NIL.
Filled in conjectures involving the concept of
MAP-JOIN-BAG-OF-STRUCS&IDENTITY.
0 conjectures involving the concept existed originally on
MAP-JOIN-BAG-OF-STRUCS&IDENTITY.
8 potential new entries were just proposed.
Eliminating duplicates, the newly constructed
conjectures involving the concept are:
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is a specialization of REAR)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is a specialization of
COMPOSE-IDENTITY&IDENTITY)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is the same as
MAP-JOIN-BAG-OF-STRUCS&REAR , and from now on we will call all
MAP-JOIN-BAG-OF-STRUCS&IDENTITY 's as MAP-JOIN-BAG-OF-STRUCS&REAR
's .
)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is a specialization of
MAP-JOIN-BAG-OF-STRUCS&REAR)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is a specialization of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is the same as
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY , and from now on we will call
all MAP-JOIN-BAG-OF-STRUCS&IDENTITY 's as
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY 's .
)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is a specialization of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY)
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY is a specialization of IDENTITY)
After eliminating duplicate and already-known entries, AM finds that.
only 14 new, distinct conjectures involving the concept of
MAP-JOIN-BAG-OF-STRUCS&IDENTITY had to be added.
Do-thresh raised from 10 to 100.
This Cand used 32.634 cpu seconds.
The top 3 Cands are:
1: Check all boundary examples of Map-join-set-of-strucs&identity
2: Construct an operation which is the inverse of:
Map-replace2-set-struc&set-of-lists-proj2
3: Fill in some examples of Non-empty-struc
I choose first Cand. OK? yes.
The reason is: (Some boundary examples were recently added
to MAP-JOIN-SET-OF-STRUCS&IDENTITY , entries that AM previously thought
were examples)
Beginning 62nd cycle.
Checked boundary examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
2 entries were there initially.
2 had to be completely discarded.
1 entries are present now.
Do-thresh raised from 100 to 170.
This Cand used 1.209 cpu seconds.
The top 3 Cands are:
1: Construct an operation which is the inverse of:
Map-replace2-set-struc&set-of-lists-proj2
2: Fill in some examples of Non-empty-struc
3: Fill in some examples of Empty-struc
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 is
interesting , an Operation , 1 known examples , and I have never
tried to invert it)
Beginning 63rd cycle.
Do-thresh raised from 170 to 221.
This Cand used .999 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Non-empty-struc
2: Fill in some examples of Empty-struc
3: Fill in some conjectures involving the concept of
Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of NON-EMPTY-STRUC
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for NON-EMPTY-STRUC yet)
Beginning 64th cycle.
(ANYB-E-VIEW compiling)
(ANYB-E-VIEW (BA1 BA2 BA3 BA4) NIL)
Running at 17343 Load av. = 1.76, used 0:25:55.7 in 1:07:17
GC: 8
Running at 23676 Load av. = 1.70, used 0:26:26.3 in 1:07:51
13426, 13426 FREE WORDS
Creating new Being, similar to NON-EMPTY-STRUC, named
INT-NON-EMPTY-STRUC, but restricted so as to make it more interesting.
An INT-NON-EMPTY-STRUC is any NON-EMPTY-STRUC for which (Each
pair of elements satisfies the same interesting predicate P (for some
P)).
Filled in examples of NON-EMPTY-STRUC.
0 examples existed originally on NON-EMPTY-STRUC.
25 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(VECTOR A)
(VECTOR B)
(VECTOR A B)
(VECTOR A A)
(VECTOR B A)
(VECTOR A A B)
(VECTOR D M I F 0)
(VECTOR B (BAG B) (CLASS) A)
(BAG A)
(BAG B)
(BAG A B)
(BAG A A)
(BAG A A B)
(BAG 0 D F I M)
(BAG A B (BAG B) (CLASS))
(BAG DON ED)
(BAG R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6)
(CLASS DON ED)
(CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6)
(CLASS A B)
(CLASS 0 D F I M)
(CLASS A B (BAG B) (CLASS))
(CLASS A)
(CLASS B)
(VECTOR BAG)
After eliminating duplicate and already-known entries, AM finds that.
all 25 new, distinct examples of NON-EMPTY-STRUC had to be added.
Do-thresh raised from 221 to 257.
This Cand used 43.78 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Int-non-empty-struc
2: Fill in some examples of Empty-struc
3: Fill in some conjectures involving the concept of
Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Any example of INT-NON-EMPTY-STRUC is
automatically an interesting example of NON-EMPTY-STRUC)
Beginning 65th cycle.
(INT-NON-EMPTY-STRUC-E-DEFN compiling)
(INT-NON-EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))
Running at 1454 Load av. = 1.76, used 0:27:10.9 in 1:08:52
GC: 8
Running at 23676 Load av. = 1.79, used 0:27:24.2 in 1:09:08
12878, 13389 FREE WORDS
Running at 4456 Load av. = 1.89, used 0:27:29.6 in 1:09:16
Won't try to create a restricted interesting version of
INT-NON-EMPTY-STRUC.
Filled in examples of INT-NON-EMPTY-STRUC.
0 examples existed originally on INT-NON-EMPTY-STRUC.
18 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(VECTOR A)
(VECTOR B)
(VECTOR A A)
(BAG A)
(BAG B)
(BAG A A)
(CLASS A)
(CLASS B)
(VECTOR BAG)
After eliminating duplicate and already-known entries, AM finds that.
only 9 new, distinct examples of INT-NON-EMPTY-STRUC had to be added.
Do-thresh raised from 257 to 286.
This Cand used 48.698 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Empty-struc
2: Fill in some conjectures involving the concept of
Map-join-set-of-strucs&identity
3: Fill in some conjectures involving the concept of
Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of EMPTY-STRUC
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for EMPTY-STRUC yet)
Beginning 66th cycle.
GC: 8
13917, 13917 FREE WORDS
Running at 6026 Load av. = 1.57, used 0:28:37.4 in 1:10:40
Won't try to create a restricted interesting version of EMPTY-STRUC.
Filled in examples of EMPTY-STRUC.
0 examples existed originally on EMPTY-STRUC.
4 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(VECTOR)
(BAG)
(CLASS)
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of EMPTY-STRUC had to be added.
Do-thresh raised from 286 to 309.
This Cand used 46.461 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of
Map-join-set-of-strucs&identity
2: Fill in some conjectures involving the concept of
Map-join-struc-of-lists&identity
3: Fill in some examples of
Map-replace2-int-set-struc&bag-of-strucs-proj2
I choose first Cand. OK? ?
There are 163 total Candidates on CANDS.
In more detail, the top Cands are:
1: value = 401; Fill in some conjectures involving the concept of
Map-join-set-of-strucs&identity
The reason is: (Examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY
remain after checking , to compare against other concepts)
2: value = 401; Fill in some conjectures involving the concept of
Map-join-struc-of-lists&identity
The reason is: (Examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
remain after checking , to compare against other concepts)
3: value = 392; Fill in some examples of
Map-replace2-int-set-struc&bag-of-strucs-proj2
The 2 reasons are:
(Anyb-exs specifically asked for some examples of
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 , while trying to
Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 yet)
4: value = 389; Fill in some examples of Inv-map-join
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-MAP-JOIN
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-MAP-JOIN yet)
5: value = 386; Fill in some examples of Inv-int-compose
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-INT-COMPOSE
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-INT-COMPOSE yet)
6: value = 382; Fill in some examples of Coa-map-replace2
The 2 reasons are:
(Anyb-exs specifically asked for some examples of COA-MAP-REPLACE2
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for COA-MAP-REPLACE2 yet)
Please type y, n, a number, or just wait 4 seconds.
yes.
The reason is: (Examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY
remain after checking , to compare against other concepts)
Beginning 67th cycle.
Failed. Tried to fill in new conjectures involving the concept of
MAP-JOIN-SET-OF-STRUCS&IDENTITY.
This Cand used 18.362 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of
Map-join-struc-of-lists&identity
2: Fill in some examples of
Map-replace2-int-set-struc&bag-of-strucs-proj2
3: Fill in some examples of Inv-map-join
I choose first Cand. OK? yes.
The reason is: (Examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
remain after checking , to compare against other concepts)
Beginning 68th cycle.
GC: 8
13807, 13807 FREE WORDS
MAP-JOIN-STRUC-OF-LISTS&IDENTITY apparently is a generalization of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY.
MAP-JOIN-STRUC-OF-LISTS&IDENTITY apparently is a generalization of
MAP-JOIN-BAG-OF-STRUCS&REAR.
Filled in conjectures involving the concept of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
1 conjectures involving the concept existed originally on
MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
2 potential new entries were just proposed.
Eliminating duplicates, the newly constructed
conjectures involving the concept are:
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY is a generalization of
MAP-JOIN-BAG-OF-STRUCS&REAR)
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY is a generalization of
MAP-JOIN-STRUC-OF-STRUCS&IDENTITY)
After eliminating duplicate and already-known entries, AM finds that.
only 4 new, distinct conjectures involving the concept of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY had to be added.
Do-thresh raised from 308 to 326.
This Cand used 19.686 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Map-replace2-int-set-struc&bag-of-strucs-proj2
2: Fill in some examples of Inv-map-join
3: Fill in some examples of Inv-int-compose
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 , while trying to
Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 yet)
Beginning 69th cycle.
(MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2-E-ALGS compiling)
(MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2-E-ALGS (BA1 BA2 BA3
BA4 BA5) NIL)
Record of attempts to find examples:
An ex ( sought) is: (CLASS)++++++++++++++++++++++++++
Found 26 examples ( and 0 non-exs), in 1.065 secs.
A nice ratio of exs/non-exs was encountered for
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2
Won't try to create a restricted interesting version of
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2.
Filled in examples of MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2.
0 examples existed originally on
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2.
27 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((CLASS B) (BAG) (CLASS (BAG)))
((CLASS) (BAG) (CLASS))
((CLASS A) (BAG) (CLASS (BAG)))
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of
MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 had to be added.
Do-thresh raised from 326 to 338.
This Cand used 17.676 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Inv-map-join
2: Fill in some examples of Inv-int-compose
3: Fill in some examples of Coa-map-replace2
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-MAP-JOIN
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-MAP-JOIN yet)
Beginning 70th cycle.
Record of attempts to find examples:
(INV-MAP-JOIN-E-ALGS compiling)
(INV-MAP-JOIN-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(MAP-JOIN-E-DEFN compiling)
(MAP-JOIN-E-DEFN (BA1 BA2 BA3) NIL)
---------
An ex ( sought) is: (CLASS (VECTOR BAG-OF-STRUCS IDENTITY))+
GC: 8
13943, 13943 FREE WORDS
Running at 275264 Load av. = 1.74, used 0:-30:40.3 in 1:13:57
--------+----------
Found 2 examples ( and 28 non-exs), in 39.535 secs.
A nice ratio of exs/non-exs was encountered for INV-MAP-JOIN
(INVERTED-OP-EXS-E-FILLIN1 compiling)
(INVERTED-OP-EXS-E-FILLIN1 (BA1) NIL)
Won't try to create a restricted interesting version of INV-MAP-JOIN.
Filled in examples of INV-MAP-JOIN.
0 examples existed originally on INV-MAP-JOIN.
8 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(MAP-JOIN-BAG-OF-STRUCS&IDENTITY (CLASS (VECTOR BAG-OF-STRUCS
IDENTITY)))
(MAP-JOIN-SET-OF-LISTS&IDENTITY (CLASS (VECTOR SET-OF-LISTS
IDENTITY)))
(MAP-JOIN-STRUC-OF-LISTS&IDENTITY (CLASS (VECTOR STRUC-OF-LISTS
IDENTITY)))
(MAP-JOIN-BAG-OF-STRUCS&REAR (CLASS (VECTOR BAG-OF-STRUCS REAR)))
(MAP-JOIN-SET-OF-STRUCS&IDENTITY (CLASS (VECTOR SET-OF-STRUCS
IDENTITY)))
(MAP-JOIN-STRUC-OF-STRUCS&IDENTITY (CLASS (VECTOR STRUC-OF-STRUCS
IDENTITY)))
After eliminating duplicate and already-known entries, AM finds that.
only 6 new, distinct examples of INV-MAP-JOIN had to be added.
Do-thresh raised from 338 to 347.
This Cand used 52.914 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Inv-int-compose
2: Fill in some examples of Coa-map-replace2
3: Fill in some examples of Inv-map-replace2
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-INT-COMPOSE
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-INT-COMPOSE yet)
Beginning 71st cycle.
Record of attempts to find examples:
(INV-INT-COMPOSE-E-ALGS compiling)
(INV-INT-COMPOSE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
----
GC: 18
Jogging at 22447 Load av. = 2.27, used 0:31:23.7 in 1:15:03
3027, 3027 FREE WORDS
-------
An ex ( sought) is: (CLASS (VECTOR
MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2))+--------+-------+---
GC: 18
Jogging at 22416 Load av. = 2.59, used 0:31:49.6 in 1:15:46
3027, 3027 FREE WORDS
-------------+--++-+----+---
GC: 18
3027, 3027 FREE WORDS
---+------------------------
GC: 18
Walking at 23676 Load av. = 3.05, used 0:32:32.5 in 1:17:01
3027, 3027 FREE WORDS
---------+---------------+--
GC: 18
3027, 3027 FREE WORDS
--+-------------+-----------
GC: 18
3027, 3027 FREE WORDS
------------------+--
Found 14 examples ( and 151 non-exs), in 35.863 secs.
A nice ratio of exs/non-exs was encountered for INV-INT-COMPOSE
Won't try to create a restricted interesting version of INV-INT-COMPOSE
.
Filled in examples of INV-INT-COMPOSE.
0 examples existed originally on INV-INT-COMPOSE.
26 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&INT-SET-STR
**U-PROJ
(CLASS (VECTOR MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2)))
(
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&BAG-OF-STRU
**-PROJ
(CLASS (VECTOR MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2)))
(COMPOSE-IDENTITY&IDENTITY (CLASS (VECTOR IDENTITY IDENTITY)))
(COMPOSE-PROJ2&PROJ2 (CLASS (VECTOR PROJ2 PROJ2)))
(COMPOSE-SET-STRUC-INTERSECT&SET-STRUC-DIFF (CLASS (VECTOR
SET-STRUC-INTERSECT SET-STRUC-DIFF)))
(COMPOSE-PROJ2&COMPOSE-PROJ2&MAP-JOIN (CLASS (VECTOR PROJ2
COMPOSE-PROJ2&MAP-JOIN)))
(COMPOSE-COALESCE&RESTRICT (CLASS (VECTOR COALESCE RESTRICT)))
(COMPOSE-COMPOSE&INT-COMPOSE (CLASS (VECTOR COMPOSE INT-COMPOSE)))
(COMPOSE-MAP-REPLACE&RESTRICT (CLASS (VECTOR MAP-REPLACE RESTRICT)
**))
(COMPOSE-INV-OP&COALESCE (CLASS (VECTOR INV-OP COALESCE)))
(COMPOSE-STRUCTURE-DELETE&STRUCTURE-INSERT (CLASS (VECTOR
STRUCTURE-DELETE STRUCTURE-INSERT)))
(COMPOSE-COALESCE&INV-OP (CLASS (VECTOR COALESCE INV-OP)))
After eliminating duplicate and already-known entries, AM finds that.
only 12 new, distinct examples of INV-INT-COMPOSE had to be added.
Do-thresh raised from 347 to 354.
This Cand used 48.255 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Coa-map-replace2
2: Fill in some examples of Inv-map-replace2
3: Fill in some examples of Oset-struc
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of COA-MAP-REPLACE2
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for COA-MAP-REPLACE2 yet)
Beginning 72nd cycle.
Sorry, AM ran out of time, trying to find an example of
COA-MAP-REPLACE2, which by the way reduces to MAP-REPLACE2, plus 1
new conditions.
Record of attempts to find examples:
(COA-MAP-REPLACE2-E-ALGS compiling)
(COA-MAP-REPLACE2-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
---
Name of new Being is too long:
MR2- BAG-OF-STRUCS &
BAG-OF-STRUCS-MAP-REPLACE2-STRUC-OF-LISTS&BAG-OF-STRUCS-STRUCTURE-INSERT
An ex ( sought) is:
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-STRU-OF-LIST&BAG-OF-STRU-STRU-INSE+
-----
Name of new Being is too long:
MR2- BAG-OF-STRUCS &
BAG-OF-STRUCS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2
+-----+--------------
Name of new Being is too long:
MR2- SET-OF-STRUCS &
SET-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2
+-----
Name of new Being is too long:
MR2- SET-OF-LISTS &
SET-OF-LISTS-MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT
+-----
Name of new Being is too long:
MR2- STRUC-OF-LISTS &
STRUC-OF-LISTS-MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2
+-----+-
GC: 18
3027, 3027 FREE WORDS
-+------------++----------------+-----------
Name of new Being is too long:
MR2- SET-OF-LISTS &
SET-OF-LISTS-MAP-REPLACE2-SET-OF-STRUCS&INT-SET-STRUC-STRUCTURE-INSERT
+-++---+----
Name of new Being is too long:
MR2- BAG-OF-STRUCS &
BAG-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2
+-----+-------+----+----
Name of new Being is too long:
MR2- BAG-OF-STRUCS &
BAG-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2
+-------
Name of new Being is too long:
MR2- BAG-OF-STRUCS &
BAG-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2
+-----------------------
Name of new Being is too long:
MR2- BAG-OF-STRUCS &
BAG-OF-STRUCS-MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2
+--------+--
Found 23 examples ( and 151 non-exs), in 36.95 secs.
A nice ratio of exs/non-exs was encountered for COA-MAP-REPLACE2
Won't try to create a restricted interesting version of
COA-MAP-REPLACE2.
Filled in examples of COA-MAP-REPLACE2.
0 examples existed originally on COA-MAP-REPLACE2.
23 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(BAG-OF-STRUCS
MAP-REPLACE2-STRUC-OF-LISTS&BAG-OF-STRUCS-STRUCTURE-INSERT
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-STRU-OF-LIST&BAG-OF-STRU-STRU-INSE)
(BAG-OF-STRUCS MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-BAG-OF-LIST&NON-EMPT-STRU-PROJ)
(BAG-OF-LISTS MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2)
(SET-OF-STRUCS MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2
MR2-SET-OF-STRU&SET-OF-STRU-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ)
(SET-OF-LISTS
MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
**)
(STRUC-OF-LISTS MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ)
(SET-STRUC PROJ2 MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2)
(STRUC-OF-LISTS PROJ2
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2)
(BAG-OF-STRUCS MAP-REPLACE2-NON-EMPTY-STRUC&LIST-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&LI
**ST-STRUC-PROJ2)
(INT-NON-EMPTY-STRUC PROJ2
MAP-REPLACE2-INT-NON-EMPTY-STRUC&INT-NON-EMPTY-STRUC-PROJ2)
(BAG-OF-STRUCS MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-STRUCS-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-BAG-OF-LISTS&BAG-O
**F-STRUCS-PROJ2)
(SET-OF-LISTS
MAP-REPLACE2-SET-OF-STRUCS&INT-SET-STRUC-STRUCTURE-INSERT
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE)
(NON-EMPTY-STRUC PROJ2
MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2)
(BAG-OF-STRUCS MAP-REPLACE2-LIST-STRUC&NON-EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-LIST-STRUC&NON-EMP
**TY-STRUC-PROJ2)
(BAG-OF-STRUCS MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ)
(INT-SET-STRUC COMPOSE-IDENTITY&OSET-STRUC-INSERT
MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-COMPOSE-IDENTITY&OSET-STRUC-INS
**ERT)
(BAG-OF-STRUCS MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&NON-EMPT-STRU-PROJ)
(BAG-OF-STRUCS MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&NON-EMPT-STRU-PROJ-1)
(BAG-OF-STRUCS MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-BAG-OF-STRU&BAG-OF-STRU-PROJ)
(LIST-STRUC PROJ1 MAP-REPLACE2-LIST-STRUC&LIST-STRUC-PROJ1)
After eliminating duplicate and already-known entries, AM finds that.
all 23 new, distinct examples of COA-MAP-REPLACE2 had to be added.
Do-thresh raised from 354 to 359.
This Cand used 83.911 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Inv-map-replace2
2: Fill in some examples of Oset-struc
3: Fill in some examples of Ord-pair
I choose first Cand. OK? ?
There are 155 total Candidates on CANDS.
In more detail, the top Cands are:
1: value = 382; Fill in some examples of Inv-map-replace2
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-MAP-REPLACE2
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-MAP-REPLACE2 yet)
2: value = 380; Fill in some examples of Oset-struc
The 2 reasons are:
(Anyb-exs specifically asked for some examples of OSET-STRUC
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for OSET-STRUC yet)
3: value = 380; Fill in some examples of Ord-pair
The 2 reasons are:
(Anyb-exs specifically asked for some examples of ORD-PAIR ,
while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for ORD-PAIR yet)
4: value = 377; Fill in some examples of Inv-compose
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-COMPOSE
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-COMPOSE yet)
5: value = 373; Check all
things which just barely miss being examples of
Map-join-set-of-lists&identity
The reason is: (Some things which just barely miss being examples
were recently added to MAP-JOIN-SET-OF-LISTS&IDENTITY , entries that
AM previously thought were boundary examples)
6: value = 351; Fill in some examples of Map-replace
The 2 reasons are:
(Anyb-exs specifically asked for some examples of MAP-REPLACE
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for MAP-REPLACE yet)
Please type y, n, a number, or just wait 4 seconds.
yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-MAP-REPLACE2
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-MAP-REPLACE2 yet)
Beginning 73rd cycle.
Record of attempts to find examples:
(INV-MAP-REPLACE2-E-ALGS compiling)
(INV-MAP-REPLACE2-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
An ex ( soughtπinterrupted before PRIN1
(PRIN1 broken)
:CARC(T)
380 (FILLIN OSET-STRUC EXS)
380 (FILLIN ORD-PAIR EXS)
377 (FILLIN INV-COMPOSE EXS)
373 (CHECK MAP-JOIN-SET-OF-LISTS&IDENTITY EXS-NOT-BDY)
351 (FILLIN MAP-REPLACE EXS)
348 (CHECK EMPTY-STRUC EXS)
348 (CHECK INT-NON-EMPTY-STRUC EXS)
348 (CHECK NON-EMPTY-STRUC EXS)
336 (CHECK MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 EXS)
388 (CHECK INV-MAP-JOIN EXS)
386 (CHECK INV-INT-COMPOSE EXS)
328 (CHECK COA-MAP-REPLACE2 EXS)
327 (FILLIN OBJ-EQUAL GENL)
303 (CHECK MAP-JOIN EXS)
300 (CHECK MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS)
298 (FILLIN SET-STRUC EXS-BDY)
296 (CHECK MAP-REPLACE2 EXS)
293 (CHECK INT-COMPOSE EXS)
293 (CHECK COMPOSE EXS)
473 (FILLIN SET-OF-LISTS EXS)
286 (CHECK BAG-STRUC EXS-NOT-BDY)
278 (CHECK EMPTY-STRUC EXS-NOT-BDY)
270 (FILLIN MAP-JOIN-STRUC-OF-STRUCS&IDENTITY TIES)
266 (CHECK INT-NON-EMPTY-STRUC EXS-NOT-BDY)
262 (FILLIN OBJ-EQUAL EXS-BDY)
256 (FILLIN INV-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 ALGS)
256 (FILLIN INT-SET-STRUC EXS-BDY)
250 (CHECK NON-EMPTY-STRUC EXS-NOT-BDY)
250 (CHECK MAP-JOIN-SET-OF-STRUCS&IDENTITY EXS-NOT-BDY)
245 (FILLIN UNORD-OBJ-EXS EXS)
245 (FILLIN STRUCTURE-MEMB EXS)
245 (FILLIN STRUCTURE-INTERSECT EXS)
245 (FILLIN STRUCTURE-INSERT EXS)
245 (FILLIN STRUCTURE-EXS-BDY EXS)
245 (FILLIN STRUCTURE-EXS EXS)
245 (FILLIN STRUCTURE-EQUAL EXS)
245 (FILLIN STRUCTURE-DIFF EXS)
245 (FILLIN STRUCTURE-DELETE EXS)
245 (FILLIN STRUC-OF-LISTS EXS)
245 (FILLIN SET-STRUC-INTERSECT EXS)
245 (FILLIN SET-STRUC-INSERT EXS)
245 (FILLIN SET-STRUC-DIFF EXS)
245 (FILLIN SET-STRUC-DELETE EXS)
245 (FILLIN RESTRICT EXS)
245 (FILLIN RELATION EXS)
245 (FILLIN PROJ2 EXS)
245 (FILLIN PROJ1 EXS)
245 (FILLIN OSET-STRUC-INTERSECT EXS)
245 (FILLIN OSET-STRUC-INSERT EXS)
245 (FILLIN OSET-STRUC-DELETE EXS)
245 (FILLIN ORD-OBJ-EXS EXS)
245 (FILLIN OBJECT-EXS EXS)
245 (FILLIN NONMULT-STRUC-EXS EXS)
245 (FILLIN LIST-STRUC-INTERSECT EXS)
245 (FILLIN LIST-STRUC-INSERT EXS)
245 (FILLIN LIST-STRUC-DELETE EXS)
245 (FILLIN INVERTED-OP-EXS EXS)
245 (FILLIN CONSTRUCTIVE-OP EXS)
245 (FILLIN CONJEC EXS)
245 (FILLIN COMPOSE-EXS-D-R EXS)
245 (FILLIN COMPOSE-EXS EXS)
245 (FILLIN COMPOSE-D-R EXS)
245 (FILLIN CANONIZE EXS)
245 (FILLIN BAG-STRUC-JOIN EXS)
245 (FILLIN BAG-STRUC-INTERSECT EXS)
245 (FILLIN BAG-STRUC-INSERT EXS)
245 (FILLIN BAG-STRUC-DIFF EXS)
245 (FILLIN BAG-STRUC-DELETE EXS)
245 (FILLIN BAG-OF-LISTS EXS)
245 (FILLIN ANYB-WORTH EXS)
245 (FILLIN ANYB-VIEW EXS)
245 (FILLIN ANYB-UP-NOT EXS)
245 (FILLIN ANYB-UP EXS)
245 (FILLIN ANYB-TIES EXS)
245 (FILLIN ANYB-SUGG EXS)
245 (FILLIN ANYB-SPEC EXS)
245 (FILLIN ANYB-RESTRUC EXS)
245 (FILLIN ANYB-INV EXS)
245 (FILLIN ANYB-INTU EXS)
245 (FILLIN ANYB-INT EXS)
245 (FILLIN ANYB-IN-RAN-OF EXS)
245 (FILLIN ANYB-IN-DOM-OF EXS)
245 (FILLIN ANYB-GENL EXS)
245 (FILLIN ANYB-FILLIN2 EXS)
245 (FILLIN ANYB-FILLIN1 EXS)
245 (FILLIN ANYB-FILLIN EXS)
245 (FILLIN ANYB-EXS-NOT-BDY EXS)
245 (FILLIN ANYB-EXS-NOT EXS)
245 (FILLIN ANYB-EXS-BDY EXS)
245 (FILLIN ANYB-EXS EXS)
245 (FILLIN ANYB-DEFN-SUF EXS)
245 (FILLIN ANYB-DEFN-NEC EXS)
245 (FILLIN ANYB-DEFN EXS)
245 (FILLIN ANYB-D-R EXS)
245 (FILLIN ANYB-CHECK2 EXS)
245 (FILLIN ANYB-CHECK1 EXS)
245 (FILLIN ANYB-CHECK EXS)
245 (FILLIN ANYB-ANYP EXS)
245 (FILLIN ANYB-ANAS EXS)
245 (FILLIN ANYB-ALGS EXS)
245 (FILLIN ACTIVE-TIES EXS)
245 (FILLIN ACTIVE-EXS-NOT-BDY EXS)
245 (FILLIN ACTIVE-EXS EXS)
245 (FILLIN ACTIVE-D-R EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2 EXS)
245 (FILLIN MAP-REPLACE2-SET-OF-LISTS&INT-SET-STRUC-PROJ1 EXS)
245 (FILLIN MAP-REPLACE2-SET-OF-STRUCS&INT-SET-STRUC-STRUCTURE-INSERT
EXS)
245 (FILLIN MAP-REPLACE2-EMPTY-STRUC&OSET-STRUC-OSET-STRUC-DELETE
EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-LISTS-BAG-STRUC-INSERT
EXS)
245 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&BAG-OF-STRUCS-BAG-STRUC-INSERT
EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-STRUCS-PROJ2 EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-STRUCS&NON-EMPTY-STRUC-STRUCTURE-DIFF
EXS)
245 (FILLIN MAP-REPLACE2-SET-OF-LISTS&NON-EMPTY-STRUC-STRUCTURE-INSERT
EXS)
245 (FILLIN MAP-REPLACE2-SET-OF-LISTS&SET-OF-STRUCS-PROJ2 EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2 EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2 EXS)
245 (FILLIN MAP-REPLACE2-STRUC-OF-LISTS&BAG-OF-STRUCS-STRUCTURE-INSERT
EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2 EXS)
245 (FILLIN MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT
EXS)
245 (FILLIN MAP-REPLACE2-BAG-OF-STRUCS&SET-OF-LISTS-STRUCTURE-DIFF
EXS)
245 (FILLIN COMPOSE-MAP-REPLACE&RESTRICT EXS)
245 (FILLIN COMPOSE-STRUCTURE-MEMB&IDENTITY EXS)
245 (FILLIN COMPOSE-BAG-STRUC-INSERT&PROJ2 EXS)
245 (FILLIN COMPOSE-BAG-STRUC-INSERT&IDENTITY EXS)
245 (FILLIN COMPOSE-OSET-STRUC-DELETE&RESTRICT EXS)
245 (FILLIN COMPOSE-LIST-STRUC-INSERT&OSET-STRUC-DELETE EXS)
245 (FILLIN COMPOSE-IDENTITY&OSET-STRUC-INSERT EXS)
245 (FILLIN COMPOSE-MAP-JOIN&COMPOSE EXS)
245 (FILLIN COMPOSE-BAG-STRUC-INSERT&OSET-STRUC-INSERT EXS)
245 (FILLIN COMPOSE-PROJ2&MAP-JOIN EXS)
245 (FILLIN COMPOSE-OSET-STRUC-INSERT&OSET-STRUC-INSERT EXS)
245 (FILLIN COMPOSE-COALESCE&CANONIZE EXS)
245 (FILLIN COMPOSE-IDENTITY&LIST-STRUC-DELETE EXS)
245 (FILLIN COMPOSE-IDENTITY&MAP-REPLACE2 EXS)
245 (FILLIN COMPOSE-STRUCTURE-DELETE&MAP-REPLACE2 EXS)
245 (FILLIN COMPOSE-LIST-STRUC-DELETE&MAP-JOIN EXS)
245 (FILLIN COMPOSE-PROJ2&COMPOSE-PROJ2&MAP-JOIN EXS)
245 (FILLIN
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&INT-SET-STR
**U-PROJ
EXS)
245 (FILLIN
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&BAG-OF-STRU
**-PROJ
EXS)
245 (FILLIN COMPOSE-STRUCTURE-DELETE&STRUCTURE-INSERT EXS)
245 (FILLIN COMPOSE-SET-STRUC-INTERSECT&SET-STRUC-DIFF EXS)
245 (FILLIN COMPOSE-COMPOSE&INT-COMPOSE EXS)
245 (FILLIN COMPOSE-PROJ2&PROJ2 EXS)
245 (FILLIN COMPOSE-COALESCE&RESTRICT EXS)
334 (FILLIN MAP-REPLACE2-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2 EXS)
323 (FILLIN MAP-REPLACE2-LIST-STRUC&NON-EMPTY-STRUC-PROJ2 EXS)
323 (FILLIN MAP-REPLACE2-OSET-STRUC&SET-OF-LISTS-PROJ2 EXS)
334 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&LIST-STRUC-PROJ2 EXS)
334 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2 EXS)
323 (FILLIN MAP-REPLACE2-OSET-STRUC&OSET-STRUC-PROJ2 EXS)
308 (FILLIN MAP-REPLACE2-SET-STRUC&BAG-OF-STRUCS-STRUCTURE-DELETE
EXS)
334 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2 EXS)
190 (FILLIN BAG-STRUC EXS-BDY)
168 (FILLIN MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS-BDY)
154
:
OK
)PRIN1
is: (CLASS (VECTOR SET-OF-LISTS INT-SET-STRUC PROJ1))++--+--+-++-++-+--
--+--+--+++---+-----+-----+---+-+-+++--+---+++
Found 26 examples ( and 38 non-exs), in 17.619 secs.
A nice ratio of exs/non-exs was encountered for INV-MAP-REPLACE2
Won't try to create a restricted interesting version of
INV-MAP-REPLACE2.
Filled in examples of INV-MAP-REPLACE2.
0 examples existed originally on INV-MAP-REPLACE2.
71 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(MAP-REPLACE2-SET-OF-LISTS&INT-SET-STRUC-PROJ1 (CLASS (VECTOR
SET-OF-LISTS INT-SET-STRUC PROJ1)))
(MAP-REPLACE2-OSET-STRUC&OSET-STRUC-PROJ2 (CLASS (VECTOR
OSET-STRUC OSET-STRUC PROJ2)))
(MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2 (CLASS (VECTOR
NON-EMPTY-STRUC NON-EMPTY-STRUC PROJ2)))
(MAP-REPLACE2-SET-OF-LISTS&SET-OF-STRUCS-PROJ2 (CLASS (VECTOR
SET-OF-LISTS SET-OF-STRUCS PROJ2)))
(MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 (CLASS (VECTOR
INT-SET-STRUC BAG-OF-STRUCS PROJ2)))
(MAP-REPLACE2-LIST-STRUC&NON-EMPTY-STRUC-PROJ2 (CLASS (VECTOR
LIST-STRUC NON-EMPTY-STRUC PROJ2)))
(MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2 (CLASS (VECTOR
NON-EMPTY-STRUC INT-SET-STRUC PROJ2)))
(MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 (CLASS (VECTOR
SET-STRUC SET-OF-LISTS PROJ2)))
(MAP-REPLACE2-OSET-STRUC&SET-OF-LISTS-PROJ2 (CLASS (VECTOR
OSET-STRUC SET-OF-LISTS PROJ2)))
(MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2 (CLASS (VECTOR
BAG-OF-STRUCS BAG-OF-STRUCS PROJ2)))
(MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2 (CLASS (VECTOR
BAG-OF-LISTS NON-EMPTY-STRUC PROJ2)))
(MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2 (CLASS (VECTOR
BAG-OF-STRUCS INT-SET-STRUC PROJ2)))
(MAP-REPLACE2-STRUC-OF-LISTS&BAG-OF-STRUCS-STRUCTURE-INSERT
(CLASS (VECTOR STRUC-OF-LISTS BAG-OF-STRUCS STRUCTURE-INSERT)))
(MAP-REPLACE2-SET-OF-STRUCS&INT-SET-STRUC-STRUCTURE-INSERT (CLASS
(VECTOR SET-OF-STRUCS INT-SET-STRUC STRUCTURE-INSERT)))
(MAP-REPLACE2-EMPTY-STRUC&OSET-STRUC-OSET-STRUC-DELETE (CLASS
(VECTOR EMPTY-STRUC OSET-STRUC OSET-STRUC-DELETE)))
(MAP-REPLACE2-SET-STRUC&BAG-OF-STRUCS-STRUCTURE-DELETE (CLASS
(VECTOR SET-STRUC BAG-OF-STRUCS STRUCTURE-DELETE)))
(MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-LISTS-BAG-STRUC-INSERT (CLASS
(VECTOR BAG-OF-STRUCS BAG-OF-LISTS BAG-STRUC-INSERT)))
(MAP-REPLACE2-NON-EMPTY-STRUC&BAG-OF-STRUCS-BAG-STRUC-INSERT
(CLASS (VECTOR NON-EMPTY-STRUC BAG-OF-STRUCS BAG-STRUC-INSERT)))
(MAP-REPLACE2-NON-EMPTY-STRUC&LIST-STRUC-PROJ2 (CLASS (VECTOR
NON-EMPTY-STRUC LIST-STRUC PROJ2)))
(MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-STRUCS-PROJ2 (CLASS (VECTOR
BAG-OF-LISTS BAG-OF-STRUCS PROJ2)))
(MAP-REPLACE2-BAG-OF-STRUCS&NON-EMPTY-STRUC-STRUCTURE-DIFF (CLASS
(VECTOR BAG-OF-STRUCS NON-EMPTY-STRUC STRUCTURE-DIFF)))
(MAP-REPLACE2-SET-OF-LISTS&NON-EMPTY-STRUC-STRUCTURE-INSERT
(CLASS (VECTOR SET-OF-LISTS NON-EMPTY-STRUC STRUCTURE-INSERT)))
(MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2 (CLASS (VECTOR
BAG-OF-STRUCS EMPTY-STRUC PROJ2)))
(MAP-REPLACE2-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2 (CLASS (VECTOR
EMPTY-STRUC NON-EMPTY-STRUC PROJ2)))
(MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT (CLASS
(VECTOR INT-SET-STRUC INT-SET-STRUC STRUCTURE-INSERT)))
(MAP-REPLACE2-BAG-OF-STRUCS&SET-OF-LISTS-STRUCTURE-DIFF (CLASS
(VECTOR BAG-OF-STRUCS SET-OF-LISTS STRUCTURE-DIFF)))
(
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-STRU-OF-LIST&BAG-OF-STRU-STRU-INSE
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-STRUC-OF-LISTS&BAG-OF-STRUCS-STRUCTURE-INSERT)))
(
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-BAG-OF-LIST&NON-EMPT-STRU-PROJ
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2)))
(
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
(CLASS (VECTOR BAG-OF-LISTS BAG-OF-LISTS
MAP-REPLACE2-BAG-OF-LISTS&NON-EMPTY-STRUC-PROJ2)))
(
MR2-SET-OF-STRU&SET-OF-STRU-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
(CLASS (VECTOR SET-OF-STRUCS SET-OF-STRUCS
MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2)))
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
(CLASS (VECTOR SET-OF-LISTS SET-OF-LISTS
MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT)))
(
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
(CLASS (VECTOR STRUC-OF-LISTS STRUC-OF-LISTS
MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2)))
(MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2 (CLASS (VECTOR SET-STRUC
SET-STRUC PROJ2)))
(MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 (CLASS (VECTOR
STRUC-OF-LISTS STRUC-OF-LISTS PROJ2)))
(
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&LI
**ST-STRUC-PROJ2
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-NON-EMPTY-STRUC&LIST-STRUC-PROJ2)))
(MAP-REPLACE2-INT-NON-EMPTY-STRUC&INT-NON-EMPTY-STRUC-PROJ2
(CLASS (VECTOR INT-NON-EMPTY-STRUC INT-NON-EMPTY-STRUC PROJ2)))
(
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-BAG-OF-LISTS&BAG-O
**F-STRUCS-PROJ2
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-STRUCS-PROJ2)))
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
(CLASS (VECTOR SET-OF-LISTS SET-OF-LISTS
MAP-REPLACE2-SET-OF-STRUCS&INT-SET-STRUC-STRUCTURE-INSERT)))
(
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-LIST-STRUC&NON-EMP
**TY-STRUC-PROJ2
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-LIST-STRUC&NON-EMPTY-STRUC-PROJ2)))
(
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2)))
(
MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-COMPOSE-IDENTITY&OSET-STRUC-INS
**ERT
(CLASS (VECTOR INT-SET-STRUC INT-SET-STRUC
COMPOSE-IDENTITY&OSET-STRUC-INSERT)))
(
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&NON-EMPT-STRU-PROJ
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2)))
(
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&NON-EMPT-STRU-PROJ-1
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2)))
(MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-BAG-OF-STRU&BAG-OF-STRU-PROJ
(CLASS (VECTOR BAG-OF-STRUCS BAG-OF-STRUCS
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2)))
(MAP-REPLACE2-LIST-STRUC&LIST-STRUC-PROJ1 (CLASS (VECTOR
LIST-STRUC LIST-STRUC PROJ1)))
After eliminating duplicate and already-known entries, AM finds that.
only 45 new, distinct examples of INV-MAP-REPLACE2 had to be added.
Do-thresh raised from 359 to 363.
This Cand used 42.552 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Oset-struc
2: Fill in some examples of Ord-pair
3: Fill in some examples of Inv-compose
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of OSET-STRUC
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for OSET-STRUC yet)
Beginning 74th cycle.
GC: 8
Running at 22277 Load av. = 1.82, used 0:36:01.3 in 1:22:56
10466, 13021 FREE WORDS
(OSET-STRUC-INSERT-E-ALGS compiling)
(OSET-STRUC-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of OSET-STRUC.
Filled in examples of OSET-STRUC.
0 examples existed originally on OSET-STRUC.
67 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(OSET BRUCE DON)
(OSET ED CORDELL)
(OSET)
(OSET A)
(OSET B)
(OSET A B)
(OSET B A)
(OSET D M I F 0)
(OSET B (BAG B) (CLASS) A)
(OSET 0 D F I M)
(OSET A B (BAG B) (CLASS))
(OSET DON ED)
(OSET R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6)
(OSET BAG)
After eliminating duplicate and already-known entries, AM finds that.
only 14 new, distinct examples of OSET-STRUC had to be added.
Do-thresh raised from 363 to 366.
This Cand used 24.364 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Ord-pair
2: Fill in some examples of Inv-compose
3: Check all things which just barely miss being examples of
Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of ORD-PAIR ,
while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for ORD-PAIR yet)
Beginning 75th cycle.
Won't try to create a restricted interesting version of ORD-PAIR.
Filled in examples of ORD-PAIR.
0 examples existed originally on ORD-PAIR.
4 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(PAIR LIST-STRUC-INTERSECT ANYB-SPEC)
(PAIR DOUG BRUCE)
(PAIR LIST-STRUC-INSERT CANONIZE)
(PAIR COMPOSE-EXS COMPOSE-EXS)
After eliminating duplicate and already-known entries, AM finds that.
all 4 new, distinct examples of ORD-PAIR had to be added.
Do-thresh raised from 366 to 368.
This Cand used 9.946 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Inv-compose
2: Check all things which just barely miss being examples of
Map-join-set-of-lists&identity
3: Fill in some examples of Map-replace
I choose first Cand. OK? yes.
The 2 reasons are:
(Anyb-exs specifically asked for some examples of INV-COMPOSE
, while trying to Check all Map-join-bag-of-strucs&identity examples)
(We have no examples for INV-COMPOSE yet)
Beginning 76th cycle.
Record of attempts to find examples:
(INV-COMPOSE-E-ALGS compiling)
(INV-COMPOSE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
------
An ex ( sought) is: (CLASS (VECTOR COALESCE RESTRICT))+++---+-----+--
GC: 18
3027, 3027 FREE WORDS
-+-----+----------+--+--
GC: 18
3027, 3027 FREE WORDS
---+--------+----------
GC: 18
3027, 3027 FREE WORDS
-+---+-+------------++--
GC: 18
3027, 3027 FREE WORDS
--------------------+-+-
GC: 18
3027, 3027 FREE WORDS
---------------+----++--
GC: 18
3027, 3027 FREE WORDS
-------+-----+-+---+
Found 25 examples ( and 135 non-exs), in 38.155 secs.
A nice ratio of exs/non-exs was encountered for INV-COMPOSE
Won't try to create a restricted interesting version of INV-COMPOSE.
Filled in examples of INV-COMPOSE.
0 examples existed originally on INV-COMPOSE.
41 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(COMPOSE-COALESCE&RESTRICT (CLASS (VECTOR COALESCE RESTRICT)))
(COMPOSE-BAG-STRUC-INSERT&PROJ2 (CLASS (VECTOR BAG-STRUC-INSERT
PROJ2)))
(COMPOSE-IDENTITY&IDENTITY (CLASS (VECTOR IDENTITY IDENTITY)))
(COMPOSE-COMPOSE&INT-COMPOSE (CLASS (VECTOR COMPOSE INT-COMPOSE)))
(
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&INT-SET-STR
**U-PROJ
(CLASS (VECTOR MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&INT-SET-STRUC-PROJ2)))
(COMPOSE-OSET-STRUC-INSERT&OSET-STRUC-INSERT (CLASS (VECTOR
OSET-STRUC-INSERT OSET-STRUC-INSERT)))
(COMPOSE-MAP-REPLACE&RESTRICT (CLASS (VECTOR MAP-REPLACE RESTRICT)
**))
(COMPOSE-IDENTITY&OSET-STRUC-INSERT (CLASS (VECTOR IDENTITY
OSET-STRUC-INSERT)))
(COMPOSE-IDENTITY&MAP-REPLACE2 (CLASS (VECTOR IDENTITY
MAP-REPLACE2)))
(COMPOSE-STRUCTURE-DELETE&STRUCTURE-INSERT (CLASS (VECTOR
STRUCTURE-DELETE STRUCTURE-INSERT)))
(COMPOSE-SET-STRUC-INTERSECT&SET-STRUC-DIFF (CLASS (VECTOR
SET-STRUC-INTERSECT SET-STRUC-DIFF)))
(
COM-MAP-REPL-BAG-OF-STRU&EMPT-STRU-PROJ&MAP-REPL-BAG-OF-STRU&BAG-OF-STRU
**-PROJ
(CLASS (VECTOR MAP-REPLACE2-BAG-OF-STRUCS&EMPTY-STRUC-PROJ2
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-PROJ2)))
(COMPOSE-PROJ2&COMPOSE-PROJ2&MAP-JOIN (CLASS (VECTOR PROJ2
COMPOSE-PROJ2&MAP-JOIN)))
(COMPOSE-STRUCTURE-MEMB&IDENTITY (CLASS (VECTOR STRUCTURE-MEMB
IDENTITY)))
(COMPOSE-BAG-STRUC-INSERT&IDENTITY (CLASS (VECTOR BAG-STRUC-INSERT
IDENTITY)))
(COMPOSE-OSET-STRUC-DELETE&RESTRICT (CLASS (VECTOR
OSET-STRUC-DELETE RESTRICT)))
(COMPOSE-LIST-STRUC-INSERT&OSET-STRUC-DELETE (CLASS (VECTOR
LIST-STRUC-INSERT OSET-STRUC-DELETE)))
(COMPOSE-MAP-JOIN&COMPOSE (CLASS (VECTOR MAP-JOIN COMPOSE)))
(COMPOSE-BAG-STRUC-INSERT&OSET-STRUC-INSERT (CLASS (VECTOR
BAG-STRUC-INSERT OSET-STRUC-INSERT)))
(COMPOSE-PROJ2&MAP-JOIN (CLASS (VECTOR PROJ2 MAP-JOIN)))
(COMPOSE-COALESCE&CANONIZE (CLASS (VECTOR COALESCE CANONIZE)))
(COMPOSE-IDENTITY&LIST-STRUC-DELETE (CLASS (VECTOR IDENTITY
LIST-STRUC-DELETE)))
(COMPOSE-STRUCTURE-DELETE&MAP-REPLACE2 (CLASS (VECTOR
STRUCTURE-DELETE MAP-REPLACE2)))
(COMPOSE-LIST-STRUC-DELETE&MAP-JOIN (CLASS (VECTOR
LIST-STRUC-DELETE MAP-JOIN)))
After eliminating duplicate and already-known entries, AM finds that.
only 24 new, distinct examples of INV-COMPOSE had to be added.
Do-thresh raised from 368 to 369.
This Cand used 55.277 cpu seconds.
The top 3 Cands are:
1: Check all things which just barely miss being examples of
Map-join-set-of-lists&identity
2: Fill in some examples of Map-replace
3: Check all examples of Empty-struc
I choose first Cand. OK? yes.
The reason is: (Some things which just barely miss being examples
were recently added to MAP-JOIN-SET-OF-LISTS&IDENTITY , entries that
AM previously thought were boundary examples)
Beginning 77th cycle.
(ACTIVE-EXS-NOT-BDY-E-CHECK2 compiling)
(ACTIVE-EXS-NOT-BDY-E-CHECK2 (BA1) NIL)
Checked things which just barely miss being examples of
MAP-JOIN-SET-OF-LISTS&IDENTITY.
2 entries were there initially.
1 small modifications had to be made.
2 entries are present now.
Do-thresh raised from 369 to 369.
This Cand used 2.77 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 369 to 246
Must find new candidates and merge them into CANDS.
(INT-NON-EMPTY-STRUC-E-SUGG compiling)
(INT-NON-EMPTY-STRUC-E-SUGG (BA1 BA2 BA3) NIL)
GC: 8
14150, 14150 FREE WORDS
The top 3 Cands are:
1: Coalesce Coa-map-replace2
2: Coalesce Map-join
3: Coalesce Map-replace2-int-set-struc&bag-of-strucs-proj2
I choose first Cand. OK? yes.
The reason is: (COA-MAP-REPLACE2 is interesting , an Operation
with at least two arguments , 23 known examples , and either I have
never tried to coalesce it or else I am desparate)
Beginning 78th cycle.
This Cand used .725 cpu seconds.
AM is forgetting the entire SUGG facet of the INT-NON-EMPTY-STRUC
concept.
Because: (No sense using this suggestion more than once).
AM is forgetting the entire SUGG facet of the INT-NON-EMPTY-STRUC
concept.
Because: (No sense using this suggestion more than once).
The top 3 Cands are:
1: Coalesce Map-join
2: Coalesce Map-replace2-int-set-struc&bag-of-strucs-proj2
3: Fill in some examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (MAP-JOIN is interesting , an Operation with
at least two arguments , 6 known examples , and either I have never
tried to coalesce it or else I am desparate)
Beginning 79th cycle.
This Cand used .524 cpu seconds.
The top 3 Cands are:
1: Coalesce Map-replace2-int-set-struc&bag-of-strucs-proj2
2: Fill in some examples of Map-join-set-of-strucs&identity
3: Fill in some examples of Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2
is interesting , an Operation with at least two arguments , 3 known
examples , and either I have never tried to coalesce it or else I
am desparate)
Beginning 80th cycle.
This Cand used .684 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-strucs&identity
2: Fill in some examples of Map-join-set-of-lists&identity
3: Fill in some examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-SET-OF-STRUCS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 81st cycle.
GC: 28
2402, 2402 FREE WORDS
Won't try to create a restricted interesting version of
MAP-JOIN-SET-OF-STRUCS&IDENTITY.
Filled in examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
0 examples existed originally on MAP-JOIN-SET-OF-STRUCS&IDENTITY
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY had to
be added.
Do-thresh raised from 243 to 276.
This Cand used 13.557 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-set-of-lists&identity
2: Fill in some examples of Map-join-struc-of-lists&identity
3: Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
I choose first Cand. OK? ?
There are 91 total Candidates on CANDS.
In more detail, the top Cands are:
1: value = 414; Fill in some examples of
Map-join-set-of-lists&identity
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
2: value = 414; Fill in some examples of
Map-join-struc-of-lists&identity
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
3: value = 414; Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
The reason is: (The range of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
4: value = 414; Fill in some examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
The reason is: (The range of
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 might turn out to
be the same as its domain , but there are no examples around to test
this hypothesis on)
5: value = 414; Fill in some examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
The reason is: (The range of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
6: value = 414; Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
The reason is: (The range of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Please type y, n, a number, or just wait 4 seconds.
yes.
The reason is: (The range of MAP-JOIN-SET-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 82nd cycle.
Won't try to create a restricted interesting version of
MAP-JOIN-SET-OF-LISTS&IDENTITY.
Filled in examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
0 examples existed originally on MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of MAP-JOIN-SET-OF-LISTS&IDENTITY had to
be added.
Do-thresh raised from 276 to 302.
This Cand used 12.09 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-join-struc-of-lists&identity
2: Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
3: Fill in some examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (The range of MAP-JOIN-STRUC-OF-LISTS&IDENTITY
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 83rd cycle.
Won't try to create a restricted interesting version of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Filled in examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
0 examples existed originally on MAP-JOIN-STRUC-OF-LISTS&IDENTITY
.
3 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((BAG) (BAG))
(NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
only 2 new, distinct examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY had
to be added.
Do-thresh raised from 302 to 323.
This Cand used 12.94 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
2: Fill in some examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
3: Fill in some examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
I choose first Cand. OK? yes.
The reason is: (The range of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 84th cycle.
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE-
**E-ALGS
compiling)
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE-
**E-ALGS
(BA1 BA2 BA3 BA4 BA5) NIL)
GC: 8
14680, 14680 FREE WORDS
Won't try to create a restricted interesting version of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
.
Filled in examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
.
0 examples existed originally on
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
had to be added.
Do-thresh raised from 323 to 340.
This Cand used 23.808 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
2: Fill in some examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
3: Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
I choose first Cand. OK? yes.
The reason is: (The range of
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 might turn out to
be the same as its domain , but there are no examples around to test
this hypothesis on)
Beginning 85th cycle.
(MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2-E-ALGS compiling)
(MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2-E-ALGS (BA1 BA2
BA3 BA4 BA5) NIL)
GC: 8
14925, 14925 FREE WORDS
Won't try to create a restricted interesting version of
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2.
Filled in examples of MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2
.
0 examples existed originally on
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 had to be added.
Do-thresh raised from 340 to 354.
This Cand used 19.287 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
2: Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
3: Fill in some examples of
Map-replace2-bag-of-lists&bag-of-lists-map-replace2-bag-of-lists&non-emp
**ty-struc-proj2
I choose first Cand. OK? yes.
The reason is: (The range of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 86th cycle.
(
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ-E
**-ALGS
compiling)
(
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ-E
**-ALGS
(BA1 BA2 BA3 BA4 BA5) NIL)
Won't try to create a restricted interesting version of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ.
Filled in examples of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ.
0 examples existed originally on
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
had to be added.
Do-thresh raised from 354 to 365.
This Cand used 22.438 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
2: Fill in some examples of
Map-replace2-bag-of-lists&bag-of-lists-map-replace2-bag-of-lists&non-emp
**ty-struc-proj2
3: Construct an operation which is the inverse of:
Map-replace2-int-set-struc&bag-of-strucs-proj2
I choose first Cand. OK? yes.
The reason is: (The range of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 87th cycle.
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
**-E-ALGS
compiling)
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
**-E-ALGS
(BA1 BA2 BA3 BA4 BA5) NIL)
GC: 8
14739, 14739 FREE WORDS
Won't try to create a restricted interesting version of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
.
Filled in examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
.
0 examples existed originally on
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
had to be added.
Do-thresh raised from 365 to 374.
This Cand used 23.511 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of
Map-replace2-bag-of-lists&bag-of-lists-map-replace2-bag-of-lists&non-emp
**ty-struc-proj2
2: Construct an operation which is the inverse of:
Map-replace2-int-set-struc&bag-of-strucs-proj2
3: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
I choose first Cand. OK? yes.
The reason is: (The range of
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
might turn out to be the same as its domain , but there are no examples
around to test this hypothesis on)
Beginning 88th cycle.
(
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2-E-ALGS
compiling)
(
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2-E-ALGS
(BA1 BA2 BA3 BA4 BA5) NIL)
GC: 8
14881, 14881 FREE WORDS
Won't try to create a restricted interesting version of
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
.
Filled in examples of
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
.
0 examples existed originally on
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(NIL NIL (NIL))
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct examples of
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
had to be added.
Do-thresh raised from 374 to 381.
This Cand used 26.787 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 381 to 254
Must find new candidates and merge them into CANDS.
GC: 8
14529, 14529 FREE WORDS
GC: 8
14481, 14481 FREE WORDS
The top 3 Cands are:
1: Coalesce Coa-map-replace2
2: Coalesce Map-join
3: Coalesce Map-replace2-int-set-struc&bag-of-strucs-proj2
I choose first Cand. OK? yes.
The reason is: (COA-MAP-REPLACE2 is interesting , an Operation
with at least two arguments , 23 known examples , and either I have
never tried to coalesce it or else I am desparate)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Coalesce Map-join
2: Coalesce Map-replace2-int-set-struc&bag-of-strucs-proj2
3: Construct an operation which is the inverse of:
Map-replace2-int-set-struc&bag-of-strucs-proj2
I choose first Cand. OK? yes.
The reason is: (MAP-JOIN is interesting , an Operation with
at least two arguments , 6 known examples , and either I have never
tried to coalesce it or else I am desparate)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Coalesce Map-replace2-int-set-struc&bag-of-strucs-proj2
2: Construct an operation which is the inverse of:
Map-replace2-int-set-struc&bag-of-strucs-proj2
3: Check all examples of
Map-replace2-bag-of-lists&bag-of-lists-map-replace2-bag-of-lists&non-emp
**ty-struc-proj2
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2
is interesting , an Operation with at least two arguments , 3 known
examples , and either I have never tried to coalesce it or else I
am desparate)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Construct an operation which is the inverse of:
Map-replace2-int-set-struc&bag-of-strucs-proj2
2: Check all examples of
Map-replace2-bag-of-lists&bag-of-lists-map-replace2-bag-of-lists&non-emp
**ty-struc-proj2
3: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
I choose first Cand. OK? yes.
The reason is: (MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2
is interesting , an Operation , 3 known examples , and I have never
tried to invert it)
Beginning 89th cycle.
Do-thresh raised from 251 to 273.
This Cand used .815 cpu seconds.
The top 3 Cands are:
1: Check all examples of
Map-replace2-bag-of-lists&bag-of-lists-map-replace2-bag-of-lists&non-emp
**ty-struc-proj2
2: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
3: Check all examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
have recently been added)
Beginning 90th cycle.
(
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2-E-DEFN
compiling)
(
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2-E-DEFN
(BA1 BA2 BA3) (BA4))
Won't bother looking for ties to
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
.
Checked examples of
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 3.688 cpu seconds.
The top 3 Cands are:
1: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-int-set-stru&int-set-stru-stru-inse
2: Check all examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
3: Check all examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
have recently been added)
Beginning 91st cycle.
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
**-E-DEFN
compiling)
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
**-E-DEFN
(BA1 BA2 BA3) (BA4))
Won't bother looking for ties to
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
.
Checked examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 3.27 cpu seconds.
The top 3 Cands are:
1: Check all examples of
Mr2-stru-of-list&stru-of-list-map-repl-non-empt-stru&int-set-stru-proj
2: Check all examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
3: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
have recently been added)
Beginning 92nd cycle.
(
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ-E
**-DEFN
compiling)
(
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ-E
**-DEFN
(BA1 BA2 BA3) (BA4))
Won't bother looking for ties to
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ.
Checked examples of
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 2.897 cpu seconds.
The top 3 Cands are:
1: Check all examples of
Map-replace2-struc-of-lists&struc-of-lists-proj2
2: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
3: Check all examples of Map-join-set-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 have recently been
added)
Beginning 93rd cycle.
(MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2-E-DEFN compiling)
(MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2-E-DEFN (BA1 BA2
BA3) (BA4))
Won't bother looking for ties to
MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2.
Checked examples of MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 2.986 cpu seconds.
The top 3 Cands are:
1: Check all examples of
Mr2-set-of-list&set-of-list-map-repl-set-of-stru&int-set-stru-stru-inse
2: Check all examples of Map-join-set-of-lists&identity
3: Check all examples of Map-join-set-of-strucs&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
have recently been added)
Beginning 94th cycle.
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE-
**E-DEFN
compiling)
(
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE-
**E-DEFN
(BA1 BA2 BA3) (BA4))
Won't bother looking for ties to
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
.
Checked examples of
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 3.391 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-set-of-lists&identity
2: Check all examples of Map-join-set-of-strucs&identity
3: Check all examples of Map-join-struc-of-lists&identity
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-SET-OF-LISTS&IDENTITY have recently been added)
Beginning 95th cycle.
Won't bother looking for ties to MAP-JOIN-SET-OF-LISTS&IDENTITY.
Checked examples of MAP-JOIN-SET-OF-LISTS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 1.393 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-set-of-strucs&identity
2: Check all examples of Map-join-struc-of-lists&identity
3: Fill in some examples of Map-replace2-set-struc&set-struc-proj2
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-SET-OF-STRUCS&IDENTITY have recently been added)
Beginning 96th cycle.
Won't bother looking for ties to MAP-JOIN-SET-OF-STRUCS&IDENTITY.
Checked examples of MAP-JOIN-SET-OF-STRUCS&IDENTITY.
1 entries were there initially.
1 were never confirmed or rejected.
0 entries are present now.
This Cand used 1.486 cpu seconds.
The top 3 Cands are:
1: Check all examples of Map-join-struc-of-lists&identity
2: Fill in some examples of Map-replace2-set-struc&set-struc-proj2
3: Fill in some specializations of Int-non-empty-struc
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of
MAP-JOIN-STRUC-OF-LISTS&IDENTITY have recently been added)
Beginning 97th cycle.
Won't bother looking for ties to MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Won't bother looking for ties to MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
Checked examples of MAP-JOIN-STRUC-OF-LISTS&IDENTITY.
2 entries were there initially.
2 had to be completely discarded.
0 entries are present now.
This Cand used 1.121 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Map-replace2-set-struc&set-struc-proj2
2: Fill in some specializations of Int-non-empty-struc
3: Fill in some specializations of Non-empty-struc
I choose first Cand. OK? yes.
The reason is: (We have no examples for
MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2 yet)
Beginning 98th cycle.
(MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2-E-ALGS compiling)
(MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2-E-ALGS (BA1 BA2 BA3 BA4 BA5)
NIL)
Record of attempts to find examples:
An ex ( sought) is: (CLASS (CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1
R3-2 R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3
R5-4 R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6))+++++++++++++++++++++++
GC: 8
13582, 13582 FREE WORDS
+++
Found 26 examples ( and 0 non-exs), in 1.884 secs.
A nice ratio of exs/non-exs was encountered for
MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2
Won't try to create a restricted interesting version of
MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2.
Filled in examples of MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2.
0 examples existed originally on
MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2.
27 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((CLASS A B (BAG B) (CLASS)) (CLASS DON ED) (CLASS (CLASS DON
ED) (CLASS DON ED) (CLASS DON ED) (CLASS DON ED)))
((CLASS B) (CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3
R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5
R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6) (CLASS (CLASS R2-1 R2-2 R2-3 R2-4
R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6
R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6)))
((CLASS B) (CLASS) (CLASS (CLASS)))
((CLASS DON ED) (CLASS DON ED) (CLASS (CLASS DON ED) (CLASS
DON ED)))
((CLASS DON ED) (CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2
R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4
R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6) (CLASS (CLASS R2-1 R2-2 R2-3
R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5
R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6)
(CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5 R3-6
R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1 R6-2
R6-3 R6-4 R6-5 R6-6)))
((CLASS A) (CLASS A B (BAG B) (CLASS)) (CLASS (CLASS A B (BAG
B) (CLASS))))
((CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) (CLASS A B (BAG B) (CLASS)) (CLASS (CLASS
A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B)
(CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS
A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B)
(CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS
A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B)
(CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS
A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B)
(CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS
A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B)
(CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS
A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B)
(CLASS)) (CLASS A B (BAG B) (CLASS)) (CLASS A B (BAG B) (CLASS))))
((CLASS B) (CLASS A B) (CLASS (CLASS A B)))
((CLASS A) (CLASS) (CLASS (CLASS)))
((CLASS) (CLASS) (CLASS))
((CLASS 0 D F I M) (CLASS A) (CLASS (CLASS A) (CLASS A) (CLASS
A) (CLASS A) (CLASS A)))
((CLASS A) (CLASS B) (CLASS (CLASS B)))
((CLASS A B (BAG B) (CLASS)) (CLASS B) (CLASS (CLASS B) (CLASS
B) (CLASS B) (CLASS B)))
((CLASS DON ED) (CLASS) (CLASS (CLASS) (CLASS)))
((CLASS DON ED) (CLASS A) (CLASS (CLASS A) (CLASS A)))
((CLASS A B) (CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2
R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4
R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6) (CLASS (CLASS R2-1 R2-2 R2-3
R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5
R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6)
(CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5 R3-6
R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1 R6-2
R6-3 R6-4 R6-5 R6-6)))
((CLASS) (CLASS DON ED) (CLASS))
((CLASS A B (BAG B) (CLASS)) (CLASS) (CLASS (CLASS) (CLASS)
(CLASS) (CLASS)))
((CLASS B) (CLASS A) (CLASS (CLASS A)))
((CLASS A) (CLASS R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3
R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5
R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6) (CLASS (CLASS R2-1 R2-2 R2-3 R2-4
R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5 R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6
R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1 R6-2 R6-3 R6-4 R6-5 R6-6)))
((CLASS B) (CLASS B) (CLASS (CLASS B)))
((CLASS A B (BAG B) (CLASS)) (CLASS A B) (CLASS (CLASS A B)
(CLASS A B) (CLASS A B) (CLASS A B)))
After eliminating duplicate and already-known entries, AM finds that.
only 22 new, distinct examples of
MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2 had to be added.
Do-thresh raised from 265 to 282.
This Cand used 25.037 cpu seconds.
The top 3 Cands are:
1: Fill in some specializations of Int-non-empty-struc
2: Fill in some specializations of Non-empty-struc
3: Check all examples of Empty-struc
I choose first Cand. OK? yes.
The reason is: (There are known examples of this interesting
specialization of NON-EMPTY-STRUC , so let 's go on and try to
specialize INT-NON-EMPTY-STRUC)
Beginning 99th cycle.
(ANYB-SPEC-E-FILLIN1 compiling)
(ANYB-SPEC-E-FILLIN1 (BA1) NIL)
u.d.f.
(MAXI broken)
:EDITV(CANDS)
edit
*P
((& 349 &) (& 348 &) (& 348 &) (& 348 &) (& 1000 &) (& 346 &) (& 336
&) (& 388 &) (& 386 &) (& 391 &) (& 334 &) (& 334 &) (& 334 &) (&
334 &) (& 334 &) (& 334 &) (& 334 &) (& 334 &) (& 330 &) (& 328 &) (&
327 &) (& 327 &) (& 379 &) (& 303 &) (& 300 &) (& 300 &) (& 300 &) (&
298 &) (& 296 &) (& 293 &) (& 293 &) (& 286 &) (& 286 &) (& 283 &) (&
279 &) (& 278 &) (& 270 &) (& 267 &) (& 266 &) (& 258 &) (& 258 &) (&
256 &) (& 250 &) (& 250 &) (& 250 &) (& 247 &) (& 245 &) (& 244 &) (&
228 &) (& 228 &) (& 228 &) (& 228 &) (& 228 &) (& 225 &) (& 221 &) (&
221 &) (& 221 &) (& 221 &) (& 221 &) (& 221 &) (& 220 &) (& 212 &) (&
212 &) (& 212 &) (& 211 &) (& 202 &) (& 195 &) (& 192 &) (& 187 &) (&
186 &) (& 185 &) (& 168 &) (& 168 &) (& 168 &) (& 168 &) (& 168 &) (&
168 &) (& 165 &) (& 165 &) (& 162 &) (& 160 &) (& 160 &) (& 160 &) (&
159 &) (& 158 &) (& 157 &) (& 155 &) (& 154 &) (& 153 &) (& 152 &) (&
152 &) (& 151 &) (& 150 &) (& 150 &) (& 150 &) (& 150 &) (& 150 &) (&
150 &) (& 147 &) (& 147 &) (& 144 &) (& 144 &) (& 140 &))
*E CARC(T)
349 (FILLIN NON-EMPTY-STRUC SPEC)
348 (CHECK EMPTY-STRUC EXS)
348 (CHECK INT-NON-EMPTY-STRUC EXS)
348 (CHECK NON-EMPTY-STRUC EXS)
1000 (FILLIN COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS)
346 (FILLIN INV-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS)
336 (CHECK MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 EXS)
388 (CHECK INV-MAP-JOIN EXS)
386 (CHECK INV-INT-COMPOSE EXS)
391 (CHECK INV-MAP-REPLACE2 EXS)
334 (CHECK MAP-JOIN-SET-OF-STRUCS&IDENTITY D-R)
334 (CHECK MAP-JOIN-SET-OF-LISTS&IDENTITY D-R)
334 (CHECK MAP-JOIN-STRUC-OF-LISTS&IDENTITY D-R)
334 (CHECK
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
D-R)
334 (CHECK MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 D-R)
334 (CHECK
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
D-R)
334 (CHECK
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
D-R)
334 (CHECK
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
D-R)
330 (CHECK OSET-STRUC EXS)
328 (CHECK COA-MAP-REPLACE2 EXS)
327 (CHECK ORD-PAIR EXS)
327 (FILLIN OBJ-EQUAL GENL)
379 (CHECK INV-COMPOSE EXS)
303 (CHECK MAP-JOIN EXS)
300 (CHECK MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2 EXS)
300 (FILLIN SET-STRUC EXS-BDY)
300 (CHECK MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS)
298 (FILLIN COA-INT-COMPOSE EXS)
296 (CHECK MAP-REPLACE2 EXS)
293 (CHECK INT-COMPOSE EXS)
293 (CHECK COMPOSE EXS)
286 (FILLIN COA-COMPOSE EXS)
286 (CHECK BAG-STRUC EXS-NOT-BDY)
283 (CHECK OSET-STRUC EXS-NOT-BDY)
279 (CHECK ORD-PAIR EXS-NOT-BDY)
278 (CHECK EMPTY-STRUC EXS-NOT-BDY)
270 (FILLIN MAP-JOIN-STRUC-OF-STRUCS&IDENTITY TIES)
267 (FILLIN OBJ-EQUAL EXS-BDY)
266 (CHECK INT-NON-EMPTY-STRUC EXS-NOT-BDY)
258 (FILLIN
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
TIES)
258 (FILLIN INT-SET-STRUC EXS-BDY)
256 (FILLIN INV-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 ALGS)
250 (FILLIN MAP-REPLACE EXS)
250 (CHECK NON-EMPTY-STRUC EXS-NOT-BDY)
250 (CHECK MAP-JOIN-SET-OF-STRUCS&IDENTITY EXS-NOT-BDY)
247 (FILLIN REV-ORD-PAIR EXS)
245 (FILLIN PROJ1 EXS)
244 (CHECK
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
EXS-BDY)
228 (FILLIN
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
TIES)
228 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&INT-SET-STRUC-PROJ2 EXS)
228 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2 EXS)
228 (FILLIN MAP-REPLACE2-NON-EMPTY-STRUC&LIST-STRUC-PROJ2 EXS)
228 (FILLIN MAP-REPLACE2-EMPTY-STRUC&NON-EMPTY-STRUC-PROJ2 EXS)
225 (FILLIN MAP-REPLACE2-INT-NON-EMPTY-STRUC&INT-NON-EMPTY-STRUC-PROJ2
EXS)
221 (CHECK MAP-JOIN-SET-OF-STRUCS&IDENTITY EXS-BDY)
221 (CHECK MAP-JOIN-SET-OF-LISTS&IDENTITY EXS-BDY)
221 (CHECK
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
EXS-BDY)
221 (CHECK MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 EXS-BDY)
221 (CHECK
MR2-STRU-OF-LIST&STRU-OF-LIST-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
EXS-BDY)
221 (CHECK
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-INT-SET-STRU&INT-SET-STRU-STRU-INSE
EXS-BDY)
220 (FILLIN INV-MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 ALGS)
212 (FILLIN MAP-REPLACE2-OSET-STRUC&OSET-STRUC-PROJ2 EXS)
212 (FILLIN MAP-REPLACE2-OSET-STRUC&SET-OF-LISTS-PROJ2 EXS)
212 (FILLIN MAP-REPLACE2-LIST-STRUC&NON-EMPTY-STRUC-PROJ2 EXS)
211 (FILLIN MAP-JOIN-SET-OF-LISTS&IDENTITY TIES)
202 (FILLIN MAP-JOIN-SET-OF-STRUCS&IDENTITY TIES)
195 (FILLIN
MAP-REPLACE2-BAG-OF-LISTS&BAG-OF-LISTS-MAP-REPLACE2-BAG-OF-LISTS&NON-EMP
**TY-STRUC-PROJ2
TIES)
192 (FILLIN BAG-STRUC EXS-BDY)
187 (FILLIN MAP-REPLACE2-SET-STRUC&BAG-OF-STRUCS-STRUCTURE-DELETE
EXS)
186 (FILLIN
MR2-SET-OF-LIST&SET-OF-LIST-MAP-REPL-SET-OF-STRU&INT-SET-STRU-STRU-INSE
TIES)
185 (FILLIN MAP-REPLACE2-STRUC-OF-LISTS&STRUC-OF-LISTS-PROJ2 TIES)
168 (FILLIN MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS-BDY)
168 (FILLIN MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2 EXS-BDY)
168 (FILLIN
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-NON-EMPTY-STRUC&LI
**ST-STRUC-PROJ2
EXS)
168 (FILLIN
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&INT-SET-STRU-PROJ
EXS)
168 (FILLIN
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&NON-EMPT-STRU-PROJ
EXS)
168 (FILLIN
MR2-BAG-OF-STRU&BAG-OF-STRU-MAP-REPL-NON-EMPT-STRU&NON-EMPT-STRU-PROJ-1
EXS)
165 (FILLIN COA-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS-BDY)
165 (FILLIN INV-MAP-REPLACE2-SET-STRUC&SET-OF-LISTS-PROJ2 EXS-BDY)
162 (FILLIN MAP-JOIN EXS-BDY)
160 (FILLIN NON-EMPTY-STRUC EXS-BDY)
160 (FILLIN EMPTY-STRUC EXS-BDY)
160 (FILLIN
MAP-REPLACE2-BAG-OF-STRUCS&BAG-OF-STRUCS-MAP-REPLACE2-LIST-STRUC&NON-EMP
**TY-STRUC-PROJ2
EXS)
159 (FILLIN INV-MAP-JOIN EXS-BDY)
158 (FILLIN INT-NON-EMPTY-STRUC EXS-BDY)
157 (FILLIN REV-ORD-PAIR EXS-BDY)
155 (FILLIN INT-COMPOSE EXS-BDY)
154 (FILLIN CANONIZE EXS)
153 (FILLIN MAP-REPLACE2 EXS-BDY)
152 (FILLIN COA-INT-COMPOSE EXS-BDY)
152 (FILLIN INV-INT-COMPOSE EXS-BDY)
151 (FILLIN RESTRICT EXS)
150 (FILLIN OSET-STRUC EXS-BDY)
150 (FILLIN ORD-PAIR EXS-BDY)
150 (FILLIN COMPOSE EXS-BDY)
150 (FILLIN MAP-REPLACE2-INT-SET-STRUC&BAG-OF-STRUCS-PROJ2 EXS-BDY)
150 (FILLIN COA-MAP-REPLACE2 EXS-BDY)
150 (FILLIN INV-MAP-REPLACE2 EXS-BDY)
147 (FILLIN COA-COMPOSE EXS-BDY)
147 (FILLIN INV-COMPOSE EXS-BDY)
144 (FILLIN MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-STRUCTURE-INSERT
EXS)
144 (FILLIN
MAP-REPLACE2-INT-SET-STRUC&INT-SET-STRUC-COMPOSE-IDENTITY&OSET-STRUC-INS
**ERT
EXS)
140 (FILLIN MAP-REPLACE EXS-BDY)
103
*F 327
*P
... 327 (&))
*0 PP
((CHECK ORD-PAIR EXS)
327
((Some new ", " unchecked examples of ORD-PAIR have recently been
added)))
*NX PP
((FILLIN OBJ-EQUAL GENL)
327
((The ratio of examples
to non-examples
of OBJ-EQUAL is too low ; OBJ-EQUAL is too specialized ", "
too narrow)))
*UP
*SW 1 N
N ?
*MOVE 1 TO N
*0
*MOVE N TO BEFORE 1
N ?
*MOVE -1 TO BEFORE 1
*1 P
((FILLIN OBJ-EQUAL GENL) 327 (&))
*(2 500)
*OK
CANDS
:RETURN NIL
MAXI = NIL
AM specializes the Transform defn of INT-NON-EMPTY-STRUC by replacing
(SOME (INT-PREDS) (FUNCTION (LAMBDA (P) (COND ((AND (EQ 2 (LENGTH
(GARGS P))) (EVERY (CDR BA1) (FUNCTION (LAMBDA (X) (EVERY (CDR BA1)
(FUNCTION (LAMBDA (Y) (APPLYB P (QUOTE ALGS) X Y)))))))) (RAISE-WORTH
P) (SETQ GTEMPP P))))))
by
(APPLY* (FUNCTION (LAMBDA (P) (COND ((AND (EQ 2 (LENGTH (GARGS P)))
(EVERY (CDR BA1) (FUNCTION (LAMBDA (X) (EVERY (CDR BA1) (FUNCTION
(LAMBDA (Y) (APPLYB P (QUOTE ALGS) X Y)))))))) (RAISE-WORTH P) (SETQ
GTEMPP P))))) NIL).
NON-NUMERIC ARG
NIL
in RMUL
(broken)
:RETURN 0
'BREAK' = 0
Filled in specializations of INT-NON-EMPTY-STRUC.
0 specializations existed originally on INT-NON-EMPTY-STRUC.
1 potential new entries were just proposed.
Eliminating duplicates, the newly constructed specializations are:
SPEC-INT-NON-EMPTY-STRUC
After eliminating duplicate and already-known entries, AM finds that.
all 1 new, distinct specializations of INT-NON-EMPTY-STRUC had to be
added.
Do-thresh raised from 282 to 294.
This Cand used 23.781 cpu seconds.
The top 3 Cands are:
1: Fill in some generalizations of Obj-equal
2: Fill in some specializations of Non-empty-struc
3: Check all examples of Empty-struc
I choose first Cand. OK? yes.
The reason is: (The ratio of examples to non-examples of
OBJ-EQUAL is too low ; OBJ-EQUAL is too specialized , too narrow)
Beginning 100th cycle.
(ANYB-GENL-E-FILLIN1 compiling)
(ANYB-GENL-E-FILLIN1 (BA1) NIL)
GC: 1
Streaking at 24111 Load av. = 0.80, used 0:48:16.2 in 1:46:57
Streaking at 23226 Load av. = 0.88, used 0:48:27.4 in 1:47:09
2420, 2420 FREE WORDS
Considering genlizing a recursive defn of OBJ-EQUAL
Will try to remove a conjunct.
2 possible conjuncts to choose from.
AM generalizes OBJ-EQUAL into the new concept GENL-OBJ-EQUAL, by
not recursing on the CAR of each arg.
i.e., GENL-OBJ-EQUAL will not have a recursive check
like this one, which is present in OBJ-EQUAL:
APPLYB
(QUOTE OBJ-EQUAL)
(QUOTE DEFN)
(CAR BA1)
(CAR BA2)
AM generalizes OBJ-EQUAL into the new concept GENL-OBJ-EQUAL-1,
by not recursing on the CDR of each arg.
i.e., GENL-OBJ-EQUAL-1 will not have a recursive check
like this one, which is present in OBJ-EQUAL:
APPLYB
(QUOTE OBJ-EQUAL)
(QUOTE DEFN)
(CDR BA1)
(CDR BA2)
If any of (GENL-OBJ-EQUAL GENL-OBJ-EQUAL-1) ever seems to be too
specialized, AM will consider disjoining it with other members of that
set.
Filled in generalizations of OBJ-EQUAL.
0 generalizations existed originally on OBJ-EQUAL.
2 potential new entries were just proposed.
Eliminating duplicates, the newly constructed generalizations are:
GENL-OBJ-EQUAL
GENL-OBJ-EQUAL-1
After eliminating duplicate and already-known entries, AM finds that.
all 2 new, distinct generalizations of OBJ-EQUAL had to be added.
Do-thresh raised from 294 to 335.
This Cand used 6.667 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Genl-obj-equal-1
2: Fill in some examples of Genl-obj-equal
3: Fill in some specializations of Non-empty-struc
I choose first Cand. OK? yes.
The reason is: (The generalization GENL-OBJ-EQUAL-1 of OBJ-EQUAL
is relatively new and has no exs of its own yet , excepting those
of OBJ-EQUAL)
Beginning 101st cycle.
π
?: N
Rename which existing concept? GENL-OBJ-EQUAL
What is its new name? SAME-SIZE
Done.
Record of attempts to find examples:
(GENL-OBJ-EQUAL-1-E-ALGS compiling)
(GENL-OBJ-EQUAL-1-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(GENL-OBJ-EQUAL-1-E-DEFN compiling)
(GENL-OBJ-EQUAL-1-E-DEFN (BA1 BA2 BA3) NIL)
-
An ex ( sought) is: ((VECTOR BAG) (VECTOR B (BAG B) (CLASS) A))+-----++
-+---+-------++-+--++-+------------++-------+--+--------+-----------+-+-
---------++--+--------------------++------+-+----+
Found 26 examples ( and 105 non-exs), in 8.037 secs.
A nice ratio of exs/non-exs was encountered for GENL-OBJ-EQUAL-1
Won't try to create a restricted interesting version of
GENL-OBJ-EQUAL-1.
Filled in examples of GENL-OBJ-EQUAL-1.
0 examples existed originally on GENL-OBJ-EQUAL-1.
26 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((VECTOR BAG) (VECTOR B (BAG B) (CLASS) A) T)
((OSET 0 D F I M) (OSET 0 D F I M) T)
((BAG) (BAG DON ED) T)
((OSET D M I F 0) (OSET D M I F 0) T)
((PAIR DOUG BRUCE) (PAIR DOUG BRUCE) T)
((VECTOR BAG) (VECTOR D M I F 0) T)
((VECTOR B) (VECTOR D M I F 0) T)
((BAG B) (BAG B) T)
((VECTOR D M I F 0) (VECTOR A A B) T)
((BAG A) (BAG A B) T)
((VECTOR) (VECTOR B (BAG B) (CLASS) A) T)
((OSET BRUCE DON) (OSET B A) T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) T)
((OSET R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) (OSET 0 D F I M) T)
((OSET A B (BAG B) (CLASS)) (OSET B (BAG B) (CLASS) A) T)
((OSET 0 D F I M) (OSET B) T)
((VECTOR A A) (VECTOR A B) T)
((OSET DON ED) (OSET BAG) T)
((BAG A A B) (BAG) T)
((OSET B) (OSET BRUCE DON) T)
((CLASS DON ED) (CLASS A) T)
((PAIR LIST-STRUC-INSERT CANONIZE) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) T)
((VECTOR) (VECTOR BAG) T)
((OSET A) (OSET D M I F 0) T)
((VECTOR BAG) (VECTOR BAG) T)
After eliminating duplicate and already-known entries, AM finds that.
only 25 new, distinct examples of GENL-OBJ-EQUAL-1 had to be added.
Do-thresh raised from 335 to 367.
This Cand used 29.095 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Same-size
2: Check all examples of Genl-obj-equal-1
3: Fill in some specializations of Non-empty-struc
I choose first Cand. OK? yes.
The 2 reasons are:
(Interestingness of SAME-SIZE has changed recently)
(The generalization SAME-SIZE of OBJ-EQUAL is relatively new
and has no exs of its own yet , excepting those of OBJ-EQUAL)
Beginning 102nd cycle.
(GENL-OBJ-EQUAL-E-DEFN compiling)
(GENL-OBJ-EQUAL-E-DEFN (BA1 BA2 BA3) NIL)
Record of attempts to find examples:
(GENL-OBJ-EQUAL-E-ALGS compiling)
(GENL-OBJ-EQUAL-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
-
An ex ( sought) is: ((VECTOR A) (OSET B))+---+--+--------+----++++-----
----+-+---+-+-----+-------+--+-+---+-+----------+-+----------+---+-----+
GC: 8
Running at 17224 Load av. = 1.68, used 0:49:32.3 in 1:49:00
12897, 13408 FREE WORDS
----+---+---------------+
Found 26 examples ( and 102 non-exs), in 8.032 secs.
A nice ratio of exs/non-exs was encountered for SAME-SIZE
Won't try to create a restricted interesting version of SAME-SIZE.
Filled in examples of SAME-SIZE.
0 examples existed originally on SAME-SIZE.
36 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((OSET 0 D F I M) (OSET 0 D F I M) T)
((OSET D M I F 0) (OSET D M I F 0) T)
((PAIR DOUG BRUCE) (PAIR DOUG BRUCE) T)
((BAG B) (BAG B) T)
((OSET BRUCE DON) (OSET B A) T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) T)
((OSET A B (BAG B) (CLASS)) (OSET B (BAG B) (CLASS) A) T)
((VECTOR A A) (VECTOR A B) T)
((PAIR LIST-STRUC-INSERT CANONIZE) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) T)
((VECTOR BAG) (VECTOR BAG) T)
((VECTOR A) (OSET B) T)
((BAG A B) (OSET B A) T)
((CLASS 0 D F I M) (BAG 0 D F I M) T)
((VECTOR B) (BAG A) T)
((PAIR LIST-STRUC-INTERSECT ANYB-SPEC) (PAIR DOUG BRUCE) T)
((OSET DON ED) (PAIR LIST-STRUC-INTERSECT ANYB-SPEC) T)
((BAG 0 D F I M) (VECTOR D M I F 0) T)
((VECTOR B) (BAG B) T)
((OSET BAG) (OSET A) T)
((VECTOR A A) (BAG A A) T)
((CLASS A) (VECTOR BAG) T)
((CLASS A B) (OSET A B) T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (OSET DON ED) T)
((VECTOR A) (OSET A) T)
((OSET BAG) (CLASS A) T)
((OSET A) (CLASS A) T)
((OSET B) (OSET A) T)
((BAG 0 D F I M) (OSET 0 D F I M) T)
((OSET DON ED) (OSET ED CORDELL) T)
((OSET ED CORDELL) (OSET B A) T)
((OSET A) (BAG B) T)
((OSET B A) (OSET A B) T)
((VECTOR B A) (OSET ED CORDELL) T)
((OSET A) (VECTOR BAG) T)
((OSET B A) (OSET DON ED) T)
After eliminating duplicate and already-known entries, AM finds that.
only 35 new, distinct examples of SAME-SIZE had to be added.
Do-thresh raised from 367 to 406.
This Cand used 21.725 cpu seconds.
The top 3 Cands are:
1: Check all examples of Same-size
2: Check all examples of Genl-obj-equal-1
3: Check all things which just barely miss being examples of
Same-size
I choose first Cand. OK? yes.
The reason is: (Some new , unchecked examples of SAME-SIZE
have recently been added)
Beginning 103rd cycle.
Checked examples of SAME-SIZE.
35 entries were there initially.
1 had to be completely discarded.
30 entries are present now.
4 had to be transferred elsewhere.
Do-thresh raised from 406 to 421.
This Cand used 6.917 cpu seconds.
The top 3 Cands are:
1: Fill in some conjectures involving the concept of Same-size
2: Check all examples of Genl-obj-equal-1
3: Check all things which just barely miss being examples of
Same-size
I choose first Cand. OK? yes.
The reason is: (Examples of SAME-SIZE remain after checking
, to compare against other concepts)
Beginning 104th cycle.
(OBJECT-E-DEFN compiling)
(OBJECT-E-DEFN (BA1 BA2 BA3) (BA4 TK2))